Android14 显示系统剖 10 ———— SurfaceFlinger 图层合成过程分析

阿豪 8/18/2024

更多 Framework 教程，请访问：http://ahaoframework.tech/

# 1. 引子

# 1.1 图层的概念

20240814140509

（图片来自 https://www.jianshu.com/p/b0ef7c04486d）

在很多的图形相关的软件中都有图层的概念，那什么是图层呢？

简单的说，可以将每个图层理解为一张透明的纸，将图像的各部分绘制在不同的透明纸（图层）上。透过这层纸，可以看到纸后面的东西，而且每层纸都是独立的，无论在这层纸上如何涂画，都不会影响到其他图层中的图像。也就是说，每个图层可以独立编辑或修改，最后将透明纸叠加起来，从上向下俯瞰，即可得到并实时改变最终的合成效果。

# 1.2 什么是图层合成

以 Android 原生版本的 Launcher 为例，这个场景下有四个图层，状态栏、导航栏由 SystemUI 绘制，壁纸由壁纸服务提供，图标由 Launcher 应用绘制，图层合成就是把这四个图层按既定的显示区域，展现到显示屏上。

20240814151108

图片来自：https://blog.csdn.net/jxt1234and2010/article/details/46057267?spm=1001.2014.3001.5501

每一个图层对应一块 buffer，所谓合成，就是把多个 buffer 合并成一个，然后送显。

具体怎么合成是一个复杂的工作，现代嵌入式平台通常有两类合成方法：

Client 合成，使用软件图形库合成，opengles skia 等，这些图形库通常会操作 GPU 来完成合成工作。
Device 合成，使用特定的硬件合成图层。比如高通平台的 mdp。

Device 合成效率更高，但是能力有限，不支持复杂图形的合成。Client 合成消耗资源更多，但是能力强大，支持各种复杂效果。

# 2. 合成过程的发起

在 Vsync 章节我们说到，当 sf 收到 Vsync 信号后，会回调到 Scheduler::onFrameSignal 函数：

void Scheduler::onFrameSignal(ICompositor& compositor, VsyncId vsyncId,
                          TimePoint expectedVsyncTime) {
    const TimePoint frameTime = SchedulerClock::now();
    // 关注点1
    if (!compositor.commit(frameTime, vsyncId, expectedVsyncTime)) {
        return;
    }
    // 关注点2
    compositor.composite(frameTime, vsyncId);
    compositor.sample();
}

1
2
3
4
5
6
7
8
9
10
11

这里的 compositor 实际是 SurfaceFlinger，SurfaceFlinger 实现了 ICompositor 接口。

该函数就是 sf 合成的发起点。

其中：

关注点 1 commit，对所有 layer 的变化信息做一个预处理，
关注点 2 composite，发起 layer 的合成操作

# 3. 合成过程之前的准备工作

在具体分析 commit 和 composite 两个函数实现之前，我们先来看看 SurfaceFlinger 为了完成合成工作做了哪些准备。

合成过程会涉及到以下几个对象：

RenderEngine 负责 Client 合成
HWComposer，HWComposer HAL 的客户端包装类，负责 Device 合成
BufferQueue 负责提供 buffer，buffer 用于保存合成后的结果，注意这里是图层合成阶段的 BufferQueue，不是 App 绘制阶段的 BufferQueue，不要混淆了

接下来我们来看看这几个对象的初始化过程。

在 SurfaceFlinger 的启动过程中会执行到 SurfaceFlinger::init() 函数：

// /frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

void SurfaceFlinger::init() FTL_FAKE_GUARD(kMainThreadContext) {
    // .....

    // 关注点 1
    // 构建 RenderEngine，用于 Client 合成
    auto builder = renderengine::RenderEngineCreationArgs::Builder()
                           .setPixelFormat(static_cast<int32_t>(defaultCompositionPixelFormat))
                           .setImageCacheSize(maxFrameBufferAcquiredBuffers)
                           .setUseColorManagerment(useColorManagement)
                           .setEnableProtectedContext(enable_protected_contents(false))
                           .setPrecacheToneMapperShaderOnly(false)
                           .setSupportsBackgroundBlur(mSupportsBlur)
                           .setContextPriority(
                                   useContextPriority
                                           ? renderengine::RenderEngine::ContextPriority::REALTIME
                                           : renderengine::RenderEngine::ContextPriority::MEDIUM);
  
    if (auto type = chooseRenderEngineTypeViaSysProp()) {
        builder.setRenderEngineType(type.value());
    }

    mRenderEngine = renderengine::RenderEngine::create(builder.build());
    mCompositionEngine->setRenderEngine(mRenderEngine.get());

    // ......
  
    // 关注点2
    // 创建 HWComposer 对象并传入一个 name 属性，再通过 mCompositionEngine->setHwComposer 设置对象属性。
    mCompositionEngine->setHwComposer(getFactory().createHWComposer(mHwcServiceName));
    // 这里的 this 就是 SurfaceFlinger 对象本身，因为它实现了 HWC2::ComposerCallback 回调接口
    mCompositionEngine->getHwComposer().setCallback(*this);
    // ......


    // Commit primary display.
    sp<const DisplayDevice> display;
    if (const auto indexOpt = mCurrentState.getDisplayIndex(getPrimaryDisplayIdLocked())) {
        const auto& displays = mCurrentState.displays;

        const auto& token = displays.keyAt(*indexOpt);
        const auto& state = displays.valueAt(*indexOpt);
         // 关注点3
        processDisplayAdded(token, state);

        mDrawingState.displays.add(token, state);

        //
        display = getDefaultDisplayDeviceLocked();
    }

    //......
    initScheduler(display);
    // ......
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

关注点 1，构建 RenderEngine 对象，该对象用于 GPU 合成，也叫 Client 合成
关注点 2，构建 HWComposer 对象，该对象是 HWC HAL 的客户端包装类，方便客户端使用 HWC HAL
关注点 3，初始化 Display 相关对象，我们主要关注 BufferQueue 及其相关类

# 3.1 RenderEngine 的初始化

关注点 1，初始化了一个 renderengine::RenderEngineCreationArgs::Builder 对象，接着将 builder 对象传入 create 函数构建一个 RenderEngine 对象，create 函数的实现如下：

std::unique_ptr<RenderEngine> RenderEngine::create(const RenderEngineCreationArgs& args) {

    // 构建 builder 时，没有配置 renderEngineType 参数
    // 使用默认值 RenderEngine::RenderEngineType::SKIA_GL_THREADED
    switch (args.renderEngineType) {
        case RenderEngineType::THREADED:
            ALOGD("Threaded RenderEngine with GLES Backend");
            return renderengine::threaded::RenderEngineThreaded::create(
                    [args]() { return android::renderengine::gl::GLESRenderEngine::create(args); },
                    args.renderEngineType);
        case RenderEngineType::SKIA_GL:
            ALOGD("RenderEngine with SkiaGL Backend");
            return renderengine::skia::SkiaGLRenderEngine::create(args);
        case RenderEngineType::SKIA_VK:
            ALOGD("RenderEngine with SkiaVK Backend");
            return renderengine::skia::SkiaVkRenderEngine::create(args);
        case RenderEngineType::SKIA_GL_THREADED: { // 走这个分支
            ALOGD("Threaded RenderEngine with SkiaGL Backend");
            return renderengine::threaded::RenderEngineThreaded::create(
                    [args]() {
                        return android::renderengine::skia::SkiaGLRenderEngine::create(args);
                    },
                    args.renderEngineType);
        }
        case RenderEngineType::SKIA_VK_THREADED:
            ALOGD("Threaded RenderEngine with SkiaVK Backend");
            return renderengine::threaded::RenderEngineThreaded::create(
                    [args]() {
                        return android::renderengine::skia::SkiaVkRenderEngine::create(args);
                    },
                    args.renderEngineType);
        case RenderEngineType::GLES:
        default:
            ALOGD("RenderEngine with GLES Backend");
            return renderengine::gl::GLESRenderEngine::create(args);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

create 函数会走到 SKIA_GL_THREADED 这个 case， create 一个 RenderEngineThreaded 对象返回：

std::unique_ptr<RenderEngineThreaded> RenderEngineThreaded::create(CreateInstanceFactory factory,
                                                                   RenderEngineType type) {
    return std::make_unique<RenderEngineThreaded>(std::move(factory), type);
}

1
2
3
4

实际就是 new 一个 RenderEngineThreaded，其构造函数如下：

RenderEngineThreaded::RenderEngineThreaded(CreateInstanceFactory factory, RenderEngineType type)
      : RenderEngine(type) {
    ATRACE_CALL();

    std::lock_guard lockThread(mThreadMutex);
    mThread = std::thread(&RenderEngineThreaded::threadMain, this, factory);
}

1
2
3
4
5
6
7

在构造函数中会启动一个线程，线程的主函数是 RenderEngineThreaded::threadMain：

void RenderEngineThreaded::threadMain(CreateInstanceFactory factory) NO_THREAD_SAFETY_ANALYSIS {
    ATRACE_CALL();

    if (!SetTaskProfiles(0, {"SFRenderEnginePolicy"})) {
        ALOGW("Failed to set render-engine task profile!");
    }

    if (setSchedFifo(true) != NO_ERROR) {
        ALOGW("Couldn't set SCHED_FIFO");
    }

    // SkiaGLRenderEngine 类型
    mRenderEngine = factory();

    pthread_setname_np(pthread_self(), mThreadName);

    {
        std::scoped_lock lock(mInitializedMutex);
        mIsInitialized = true;
    }
    mInitializedCondition.notify_all();

    while (mRunning) {
        const auto getNextTask = [this]() -> std::optional<Work> {
            std::scoped_lock lock(mThreadMutex);
            if (!mFunctionCalls.empty()) {
                Work task = mFunctionCalls.front();
                mFunctionCalls.pop();
                return std::make_optional<Work>(task);
            }
            return std::nullopt;
        };

        const auto task = getNextTask();

        if (task) {
            (*task)(*mRenderEngine);
        }

        std::unique_lock<std::mutex> lock(mThreadMutex);
        mCondition.wait(lock, [this]() REQUIRES(mThreadMutex) {
            return !mRunning || !mFunctionCalls.empty();
        });
    }

    // we must release the RenderEngine on the thread that created it
    mRenderEngine.reset();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

完成基本的初始化，主要是使用传入的 factory（create 的时候传入的 lamda 表达式）构建一个 SkiaGLRenderEngine 对象，然后进入一个无线循环，取 task，执行 task，然后 lock 到锁对象上，等待唤醒。

容易猜到，这里的 Task 应该就是图层的 GPU 合成工作。

最后会调用到 mCompositionEngine->setRenderEngine(mRenderEngine.get()); 把构建好的 RenderEngine 对象给到 CompositionEngine 的 mRenderEngine 成员.

// /frameworks/native/services/surfaceflinger/CompositionEngine/src/CompositionEngine.cpp
void CompositionEngine::setRenderEngine(renderengine::RenderEngine* renderEngine) {
    mRenderEngine = renderEngine;
}

1
2
3
4

# 3.2 HWComposer 的初始化

接着回到 init 函数中，我们来看看关注点 2 处：

    // 关注点2
    // 创建 HWComposer 对象并传入一个 name 属性，再通过 mCompositionEngine->setHwComposer 设置对象属性。
    mCompositionEngine->setHwComposer(getFactory().createHWComposer(mHwcServiceName));
    // 这里的 this 就是 SurfaceFlinger 对象本身，因为它实现了 HWC2::ComposerCallback 回调接口
    mCompositionEngine->getHwComposer().setCallback(*this);

1
2
3
4
5

首先，明确一点，HardWare Composor hal 是以 Binder 服务的形式存在于系统中的，这里通过 DefaultFactory 构建一个 HwComposer 对象，根据我们以往的分析源码的经验，HwComposer 大概率是一个 Binder 代理端类的包装类。

接下来我们来分析 HwComposer 的初始化过程。

// /frameworks/native/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
std::unique_ptr<HWComposer> DefaultFactory::createHWComposer(const std::string& serviceName) {
    return std::make_unique<android::impl::HWComposer>(serviceName);
}

1
2
3
4

直接 new 一个 android::impl::HWComposer，其构造函数实现如下：

// /frameworks/native/services/surfaceflinger/DisplayHardware/HWComposer.cpp
HWComposer::HWComposer(const std::string& composerServiceName)
      : HWComposer(Hwc2::Composer::create(composerServiceName)) {}

HWComposer::HWComposer(std::unique_ptr<Hwc2::Composer> composer)
      : mComposer(std::move(composer)),
        mMaxVirtualDisplayDimension(static_cast<size_t>(sysprop::max_virtual_display_dimension(0))),
        mUpdateDeviceProductInfoOnHotplugReconnect(
                sysprop::update_device_product_info_on_hotplug_reconnect(false)) {}

1
2
3
4
5
6
7
8
9

接着会调用 create 函数构造一个 AidlComposer 对象，然后调用另一个构造函数重载：

std::unique_ptr<Composer> Composer::create(const std::string& serviceName) {
    if (AidlComposer::isDeclared(serviceName)) { // 新版本都会走该分支，使用 aidl hal
        return std::make_unique<AidlComposer>(serviceName);
    }

    return std::make_unique<HidlComposer>(serviceName);
}

1
2
3
4
5
6
7

AidlComposer 是 IComposer 的包装类，IComposer 实际就是 HWComposer Hal Binder 服务的代理端对象，用于发起 Binder 远程过程调用。构造函数实现如下：

// /frameworks/native/services/surfaceflinger/DisplayHardware/AidlComposerHal.h
    std::shared_ptr<AidlIComposer> mAidlComposer;
    std::shared_ptr<AidlIComposerClient> mAidlComposerClient;

// /frameworks/native/services/surfaceflinger/DisplayHardware/AidlComposerHal.cpp
AidlComposer::AidlComposer(const std::string& serviceName) {
    // This only waits if the service is actually declared
    // 拿到代理端对象
    mAidlComposer = AidlIComposer::fromBinder(
            ndk::SpAIBinder(AServiceManager_waitForService(instance(serviceName).c_str())));
    if (!mAidlComposer) {
        LOG_ALWAYS_FATAL("Failed to get AIDL composer service");
        return;
    }

    // 拿到匿名 Binder 服务的代理端对象 mAidlComposerClient
    if (!mAidlComposer->createClient(&mAidlComposerClient).isOk()) {
        LOG_ALWAYS_FATAL("Can't create AidlComposerClient, fallback to HIDL");
        return;
    }

    addReader(translate<Display>(kSingleReaderKey));

    // If unable to read interface version, then become backwards compatible.
    int32_t version = 1;
    const auto status = mAidlComposerClient->getInterfaceVersion(&version);
    if (!status.isOk()) {
        ALOGE("getInterfaceVersion for AidlComposer constructor failed %s",
              status.getDescription().c_str());
    }
    mSupportsBufferSlotsToClear = version > 1;
    if (!mSupportsBufferSlotsToClear) {
        if (sysprop::clear_slots_with_set_layer_buffer(false)) {
            mClearSlotBuffer = sp<GraphicBuffer>::make(1, 1, PIXEL_FORMAT_RGBX_8888,
                                                       GraphicBuffer::USAGE_HW_COMPOSER |
                                                               GraphicBuffer::USAGE_SW_READ_OFTEN |
                                                               GraphicBuffer::USAGE_SW_WRITE_OFTEN,
                                                       "AidlComposer");
            if (!mClearSlotBuffer || mClearSlotBuffer->initCheck() != ::android::OK) {
                LOG_ALWAYS_FATAL("Failed to allocate a buffer for clearing layer buffer slots");
                return;
            }
        }
    }

    ALOGI("Loaded AIDL composer3 HAL service");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

在构造函数中，首先通过 ServiceManager 获取到 HWComposer Hal 的代理端对象 mAidlComposer，接着通过 mAidlComposer 发起远程调用获取到匿名 Binder 服务的代理端对象 mAidlComposerClient。都是 Binder 的基本操作了。不在细说了。总而言之，AidlComposer 类包装了与 HWC Hal 交互的接口，让使用方更为方便地操作 HWC Hal。

到这里呢，我们就梳理出了 CompositionEngine 相关类的关系图：

20240730215128

总之，CompositionEngine 是 SurfaceFlinger 与 RenderEngine 和 HWComposer 沟通的桥梁，RenderEngine 负责图层的 GPU 合成，HWComposer 负责图层的硬件合成。

HWComposer 中还有一个重要成员 mDisplayData，mDisplayData 中有一个重要成员 Display，他们都是什么初始化的呢？

本节开头的代码中：

mCompositionEngine->getHwComposer().setCallback(*this);

这里向 HwComposer 注册了一个回调，回调类型是 HWC2::ComposerCallback ，回调对象就是 SurfaceFlinger，SurfaceFlinger 实现了 HWC2::ComposerCallback 接口。

HWC2::ComposerCallback 接口的定义如下：

struct ComposerCallback {
    virtual void onComposerHalHotplug(hal::HWDisplayId, hal::Connection) = 0;
    virtual void onComposerHalRefresh(hal::HWDisplayId) = 0;
    virtual void onComposerHalVsync(hal::HWDisplayId, nsecs_t timestamp,
                                    std::optional<hal::VsyncPeriodNanos>) = 0;
    virtual void onComposerHalVsyncPeriodTimingChanged(hal::HWDisplayId,
                                                       const hal::VsyncPeriodChangeTimeline&) = 0;
    virtual void onComposerHalSeamlessPossible(hal::HWDisplayId) = 0;
    virtual void onComposerHalVsyncIdle(hal::HWDisplayId) = 0;
    virtual void onRefreshRateChangedDebug(const RefreshRateChangedDebugData&) = 0;

protected:
    ~ComposerCallback() = default;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14

当手机开机时或者有新的显示设备加入时，就会回调到这里的 onComposerHalHotplug 函数。SurfaceFlinger 中，该函数的实现如下：

void SurfaceFlinger::onComposerHalHotplug(hal::HWDisplayId hwcDisplayId,
                                          hal::Connection connection) {
    {
        std::lock_guard<std::mutex> lock(mHotplugMutex);
        mPendingHotplugEvents.push_back(HotplugEvent{hwcDisplayId, connection});
    }

    if (mScheduler) {
        mScheduler->scheduleConfigure();
    }
}

1
2
3
4
5
6
7
8
9
10
11

接着调用 mScheduler->scheduleConfigure();：

void MessageQueue::scheduleConfigure() {
    struct ConfigureHandler : MessageHandler {
        explicit ConfigureHandler(ICompositor& compositor) : compositor(compositor) {}

        void handleMessage(const Message&) override { compositor.configure(); }

        ICompositor& compositor;
    };

    // TODO(b/241285876): Batch configure tasks that happen within some duration.
    postMessage(sp<ConfigureHandler>::make(mCompositor));
}

1
2
3
4
5
6
7
8
9
10
11
12

这里会 postMessage，对应的 Handler 回调函数 handleMessage 中会接着调用 compositor.configure()，这里的 compositor 实际类型是 SurfaceFligner。

void SurfaceFlinger::configure() FTL_FAKE_GUARD(kMainThreadContext) {
    Mutex::Autolock lock(mStateLock);
    if (configureLocked()) {
        setTransactionFlags(eDisplayTransactionNeeded);
    }
}

1
2
3
4
5
6

接着调用 configureLocked：

bool SurfaceFlinger::configureLocked() {
    std::vector<HotplugEvent> events;
    {
        std::lock_guard<std::mutex> lock(mHotplugMutex);
        events = std::move(mPendingHotplugEvents);
    }

    for (const auto [hwcDisplayId, connection] : events) {
        if (auto info = getHwComposer().onHotplug(hwcDisplayId, connection)) {
            const auto displayId = info->id;
            const bool connected = connection == hal::Connection::CONNECTED;

            if (const char* const log =
                        processHotplug(displayId, hwcDisplayId, connected, std::move(*info))) {
                ALOGI("%s display %s (HAL ID %" PRIu64 ")", log, to_string(displayId).c_str(),
                      hwcDisplayId);
            }
        }
    }

    return !events.empty();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

这里会接着调用到 getHwComposer().onHotplug：

std::optional<DisplayIdentificationInfo> HWComposer::onHotplug(hal::HWDisplayId hwcDisplayId,
                                                               hal::Connection connection) {
    switch (connection) {
        case hal::Connection::CONNECTED:
            return onHotplugConnect(hwcDisplayId);
        case hal::Connection::DISCONNECTED:
            return onHotplugDisconnect(hwcDisplayId);
        case hal::Connection::INVALID:
            return {};
    }
}

1
2
3
4
5
6
7
8
9
10
11

接着调用 onHotplugConnect：

std::optional<DisplayIdentificationInfo> HWComposer::onHotplugConnect(
        hal::HWDisplayId hwcDisplayId) {
  
    // ......

    if (!isConnected(info->id)) {
        allocatePhysicalDisplay(hwcDisplayId, info->id);
    }
    return info;
}

1
2
3
4
5
6
7
8
9
10

这里会调用到 allocatePhysicalDisplay：

void HWComposer::allocatePhysicalDisplay(hal::HWDisplayId hwcDisplayId,
                                         PhysicalDisplayId displayId) {
    mPhysicalDisplayIdMap[hwcDisplayId] = displayId;

    if (!mPrimaryHwcDisplayId) {
        mPrimaryHwcDisplayId = hwcDisplayId;
    }

    // unordered_map 如果当前容器中没有以 key 为键的键值对，则其会使用该键向当前容器中插入一个新键值对。
    auto& displayData = mDisplayData[displayId];
    auto newDisplay =
            std::make_unique<HWC2::impl::Display>(*mComposer.get(), mCapabilities, hwcDisplayId,
                                                  hal::DisplayType::PHYSICAL);
    newDisplay->setConnected(true);
    displayData.hwcDisplay = std::move(newDisplay);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这里会向 mDisplayData 插入一组新的数据，同时初始化一个 HWC2::impl::Display 对象保存在 displayData.hwcDisplay 中。

HWC2::impl::Display 继承自 HWC2::Display，是显示设备的抽象：

class Display : public HWC2::Display {
    //......
    using Layers = std::unordered_map<hal::HWLayerId, std::weak_ptr<HWC2::impl::Layer>>;
    Layers mLayers;
    //......
}

1
2
3
4
5
6

有一个重要成员 mLayers，用于保存 HWC2::impl::Layer

Display 的构造函数实现如下：

Display::Display(android::Hwc2::Composer& composer,
                 const std::unordered_set<AidlCapability>& capabilities, HWDisplayId id,
                 DisplayType type)
      : mComposer(composer), mCapabilities(capabilities), mId(id), mType(type) {
    ALOGV("Created display %" PRIu64, id);
}

1
2
3
4
5
6

就是几个成员的赋值。

# 3.3 BufferQueue 的初始化

关注点 3，完成合成阶段 BufferQueue 及其相关类的初始化。

// /frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
void SurfaceFlinger::init() FTL_FAKE_GUARD(kMainThreadContext) {
    // ......
    processDisplayAdded(token, state);
    // ......
}

void SurfaceFlinger::processDisplayAdded(const wp<IBinder>& displayToken,
                                         const DisplayDeviceState& state) {

    // ......

    // 关注点 1，创建 Display 对象
    auto compositionDisplay = getCompositionEngine().createDisplay(builder.build());
    compositionDisplay->setLayerCachingEnabled(mLayerCachingEnabled);

    sp<compositionengine::DisplaySurface> displaySurface;

    // 关注点 2 创建 BufferQueue 获取到生产者和消费者
    sp<IGraphicBufferProducer> producer;

    sp<IGraphicBufferProducer> bqProducer;
    sp<IGraphicBufferConsumer> bqConsumer;

    getFactory().createBufferQueue(&bqProducer, &bqConsumer, /*consumerIsSurfaceFlinger =*/false);

    if (state.isVirtual()) { // 虚拟屏，不管
      // ......
    } else {
        ALOGE_IF(state.surface != nullptr,
                 "adding a supported display, but rendering "
                 "surface is provided (%p), ignoring it",
                 state.surface.get());
        const auto displayId = PhysicalDisplayId::tryCast(compositionDisplay->getId());
        LOG_FATAL_IF(!displayId);

        // 关注点 3
        // 创建了 FramebufferSurface 对象，FramebufferSurface 继承自 compositionengine::DisplaySurface
        // FramebufferSurface 是作为消费者的角色工作的，消费 SF GPU 合成后的图形数据
        displaySurface =
                sp<FramebufferSurface>::make(getHwComposer(), *displayId, bqConsumer,
                                             state.physical->activeMode->getResolution(),
                                             ui::Size(maxGraphicsWidth, maxGraphicsHeight));
        producer = bqProducer;
    }

    LOG_FATAL_IF(!displaySurface);

    // 关注点 4 创建 DisplayDevice，同时会创建 RenderSurface，作为生产者角色工作
    auto display = setupNewDisplayDeviceInternal(displayToken, std::move(compositionDisplay), state,
                                                 displaySurface, producer);

    if (mScheduler && !display->isVirtual()) {
        const auto displayId = display->getPhysicalId();
        {
            // TODO(b/241285876): Annotate `processDisplayAdded` instead.
            ftl::FakeGuard guard(kMainThreadContext);

            // For hotplug reconnect, renew the registration since display modes have been reloaded.
            mScheduler->registerDisplay(displayId, display->holdRefreshRateSelector());
        }

        dispatchDisplayHotplugEvent(displayId, true);
    }

    if (display->isVirtual()) {
        display->adjustRefreshRate(mScheduler->getPacesetterRefreshRate());
    }

    mDisplays.try_emplace(displayToken, std::move(display));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

关注点1，初始化 Display 对象过程，Display 对象是显示设备的抽象。

std::shared_ptr<compositionengine::Display> CompositionEngine::createDisplay(
        const DisplayCreationArgs& args) {
    return compositionengine::impl::createDisplay(*this, args);
}

namespace android::compositionengine::impl  {

    std::shared_ptr<Display> createDisplay(
            const compositionengine::CompositionEngine& compositionEngine,
            const compositionengine::DisplayCreationArgs& args) {
        return createDisplayTemplated<Display>(compositionEngine, args);
    }

    //......
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

进一步调用到 createDisplayTemplated 函数：

//  BaseDisplay -> android::compositionengine::impl::Display
// CompositionEngine -> compositionengine::CompositionEngine
template <typename BaseDisplay, typename CompositionEngine>
std::shared_ptr<BaseDisplay> createDisplayTemplated(
        const CompositionEngine& compositionEngine,
        const compositionengine::DisplayCreationArgs& args) {

    auto display = createOutputTemplated<BaseDisplay>(compositionEngine);

    display->setConfiguration(args);

    return display;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

接着调用模版函数：

// BaseOutput -> BaseDisplay -> android::compositionengine::impl::Display
// CompositionEngine -> compositionengine::CompositionEngine
template <typename BaseOutput, typename CompositionEngine, typename... Args>
std::shared_ptr<BaseOutput> createOutputTemplated(const CompositionEngine& compositionEngine,
                                                  Args... args) {

    // 定义一个内部类
    // 实际继承自 android::compositionengine::impl::Display
    class Output final : public BaseOutput {
    public:
// Clang incorrectly complains that these are unused.
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-local-typedef"

        // compositionengine::impl::OutputCompositionState
        using OutputCompositionState = std::remove_const_t<
                std::remove_reference_t<decltype(std::declval<BaseOutput>().getState())>>;
        using OutputLayer = std::remove_pointer_t<decltype(
                std::declval<BaseOutput>().getOutputLayerOrderedByZByIndex(0))>;

#pragma clang diagnostic pop

        explicit Output(const CompositionEngine& compositionEngine, Args... args)
              : BaseOutput(std::forward<Args>(args)...), mCompositionEngine(compositionEngine) {}
        ~Output() override = default;

    private:
        // compositionengine::Output overrides
        const OutputCompositionState& getState() const override { return mState; }

        OutputCompositionState& editState() override { return mState; }

        size_t getOutputLayerCount() const override {
            return mCurrentOutputLayersOrderedByZ.size();
        }

        OutputLayer* getOutputLayerOrderedByZByIndex(size_t index) const override {
            if (index >= mCurrentOutputLayersOrderedByZ.size()) {
                return nullptr;
            }
            return mCurrentOutputLayersOrderedByZ[index].get();
        }

        // compositionengine::impl::Output overrides
        const CompositionEngine& getCompositionEngine() const override {
            return mCompositionEngine;
        };

        OutputLayer* ensureOutputLayer(std::optional<size_t> prevIndex,
                                       const sp<LayerFE>& layerFE) {
            auto outputLayer = (prevIndex && *prevIndex <= mCurrentOutputLayersOrderedByZ.size())
                    ? std::move(mCurrentOutputLayersOrderedByZ[*prevIndex])
                    : BaseOutput::createOutputLayer(layerFE);
            auto result = outputLayer.get();
            mPendingOutputLayersOrderedByZ.emplace_back(std::move(outputLayer));
            return result;
        }

        void finalizePendingOutputLayers() override {
            // The pending layers are added in reverse order. Reverse them to
            // get the back-to-front ordered list of layers.
            std::reverse(mPendingOutputLayersOrderedByZ.begin(),
                         mPendingOutputLayersOrderedByZ.end());

            mCurrentOutputLayersOrderedByZ = std::move(mPendingOutputLayersOrderedByZ);
        }

        void dumpState(std::string& out) const override { mState.dump(out); }

        OutputLayer* injectOutputLayerForTest(const sp<LayerFE>& layerFE) override {
            auto outputLayer = BaseOutput::createOutputLayer(layerFE);
            auto result = outputLayer.get();
            mCurrentOutputLayersOrderedByZ.emplace_back(std::move(outputLayer));
            return result;
        }

        // Note: This is declared as a private virtual non-override so it can be
        // an override implementation in the unit tests, but otherwise is not an
        // accessible override for the normal implementation.
        virtual void injectOutputLayerForTest(std::unique_ptr<OutputLayer> outputLayer) {
            mCurrentOutputLayersOrderedByZ.emplace_back(std::move(outputLayer));
        }

        void clearOutputLayers() override {
            mCurrentOutputLayersOrderedByZ.clear();
            mPendingOutputLayersOrderedByZ.clear();
        }

        const CompositionEngine& mCompositionEngine;
        OutputCompositionState mState;
        std::vector<std::unique_ptr<OutputLayer>> mCurrentOutputLayersOrderedByZ;
        std::vector<std::unique_ptr<OutputLayer>> mPendingOutputLayersOrderedByZ;
    };

    // 构建一个内部类的对象
    return std::make_shared<Output>(compositionEngine, std::forward<Args>(args)...);
}

定义了一个 Output 函数内部类，然后 new 一个对象返回。

Output 是一个模版类，当前场景下 Output 相关类类图如下：

20240806105736

Outout 中的两个成员很重要：

        std::vector<std::unique_ptr<OutputLayer>> mCurrentOutputLayersOrderedByZ;
        std::vector<std::unique_ptr<OutputLayer>> mPendingOutputLayersOrderedByZ;

1
2

后续合成过程中就会构建新的 OutputLayer 对象并插入这两个 vector。

Display 对象到这里就初始化完成了。

关注点2 创建 BufferQueue：

// /frameworks/native/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
void DefaultFactory::createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
                                       sp<IGraphicBufferConsumer>* outConsumer,
                                       bool consumerIsSurfaceFlinger) {
    BufferQueue::createBufferQueue(outProducer, outConsumer, consumerIsSurfaceFlinger);
}

// /frameworks/native/libs/gui/BufferQueue.cpp
void BufferQueue::createBufferQueue(sp<IGraphicBufferProducer>* outProducer,
        sp<IGraphicBufferConsumer>* outConsumer,
        bool consumerIsSurfaceFlinger) {
    LOG_ALWAYS_FATAL_IF(outProducer == nullptr,
            "BufferQueue: outProducer must not be NULL");
    LOG_ALWAYS_FATAL_IF(outConsumer == nullptr,
            "BufferQueue: outConsumer must not be NULL");

    sp<BufferQueueCore> core(new BufferQueueCore());
    LOG_ALWAYS_FATAL_IF(core == nullptr,
            "BufferQueue: failed to create BufferQueueCore");

    sp<IGraphicBufferProducer> producer(new BufferQueueProducer(core, consumerIsSurfaceFlinger));
    LOG_ALWAYS_FATAL_IF(producer == nullptr,
            "BufferQueue: failed to create BufferQueueProducer");

    sp<IGraphicBufferConsumer> consumer(new BufferQueueConsumer(core));
    LOG_ALWAYS_FATAL_IF(consumer == nullptr,
            "BufferQueue: failed to create BufferQueueConsumer");

    *outProducer = producer;
    *outConsumer = consumer;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

初始化一个 BufferQueueCore，然后通过 BufferQueueCore 初始化好 Producer，Consumer。Producer 不断的 dequeueBuffer & queueBuffer ; Consumer 不断的 acquireBuffer & releaseBuffer，这样 Buffer 就流转起来了。

不论是 Producer，还是 Consumer，都是和具体的类结合起来使用：

RenderSurface 对象间接持有 producer，作为生产者
FramebufferSurface 对象会持有 consumer，作为消费者

关注点 3，初始化一个 FramebufferSurface 对象，持有 consumer，是具体的消费者，其构造函数实现如下：

FramebufferSurface::FramebufferSurface(HWComposer& hwc, PhysicalDisplayId displayId,
                                       const sp<IGraphicBufferConsumer>& consumer,
                                       const ui::Size& size, const ui::Size& maxSize)
      : ConsumerBase(consumer), // 持有 consumer 
        mDisplayId(displayId),
        mMaxSize(maxSize),
        mCurrentBufferSlot(-1),
        mCurrentBuffer(),
        mCurrentFence(Fence::NO_FENCE),
        mHwc(hwc),
        mHasPendingRelease(false),
        mPreviousBufferSlot(BufferQueue::INVALID_BUFFER_SLOT),
        mPreviousBuffer() {

    ALOGV("Creating for display %s", to_string(displayId).c_str());

    mName = "FramebufferSurface";
    mConsumer->setConsumerName(mName);
    mConsumer->setConsumerUsageBits(GRALLOC_USAGE_HW_FB |
                                       GRALLOC_USAGE_HW_RENDER |
                                       GRALLOC_USAGE_HW_COMPOSER);
    const auto limitedSize = limitSize(size);
    mConsumer->setDefaultBufferSize(limitedSize.width, limitedSize.height);
    mConsumer->setMaxAcquiredBufferCount(
            SurfaceFlinger::maxFrameBufferAcquiredBuffers - 1);

    for (size_t i = 0; i < sizeof(mHwcBufferIds) / sizeof(mHwcBufferIds[0]); ++i) {
        mHwcBufferIds[i] = UINT64_MAX;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

主要是初始化和一些配置，FramebufferSurface 内部持有一个 consumer，是 GPU 合成后 Buffer 的消费端。

接下来看关注点 4，主要任务是初始化一个 DisplayDevice 对象，同时会构建生产者对象 RenderSurface

这里会调用 setupNewDisplayDeviceInternal 函数：

sp<DisplayDevice> SurfaceFlinger::setupNewDisplayDeviceInternal(
        const wp<IBinder>& displayToken,
        std::shared_ptr<compositionengine::Display> compositionDisplay,
        const DisplayDeviceState& state,
        const sp<compositionengine::DisplaySurface>& displaySurface,
        const sp<IGraphicBufferProducer>& producer) {
  
    // 构建 DisplayDevice 的参数
    DisplayDeviceCreationArgs creationArgs(sp<SurfaceFlinger>::fromExisting(this), getHwComposer(),
                                           displayToken, compositionDisplay);
  
    creationArgs.sequenceId = state.sequenceId;
    creationArgs.isSecure = state.isSecure;
    creationArgs.displaySurface = displaySurface;
    creationArgs.hasWideColorGamut = false;
    creationArgs.supportedPerFrameMetadata = 0;

    if (const auto& physical = state.physical) {
        creationArgs.activeModeId = physical->activeMode->getId();
        const auto [kernelIdleTimerController, idleTimerTimeoutMs] =
                getKernelIdleTimerProperties(compositionDisplay->getId());

        using Config = scheduler::RefreshRateSelector::Config;
        const auto enableFrameRateOverride = sysprop::enable_frame_rate_override(true)
                ? Config::FrameRateOverride::Enabled
                : Config::FrameRateOverride::Disabled;
        Config config =
                {.enableFrameRateOverride = enableFrameRateOverride,
                 .frameRateMultipleThreshold =
                         base::GetIntProperty("debug.sf.frame_rate_multiple_threshold", 0),
                 .idleTimerTimeout = idleTimerTimeoutMs,
                 .kernelIdleTimerController = kernelIdleTimerController};

      
        creationArgs.refreshRateSelector =
                mPhysicalDisplays.get(physical->id)
                        .transform(&PhysicalDisplay::snapshotRef)
                        .transform([&](const display::DisplaySnapshot& snapshot) {
                            return std::make_shared<
                                    scheduler::RefreshRateSelector>(snapshot.displayModes(),
                                                                    creationArgs.activeModeId,
                                                                    config);
                        })
                        .value_or(nullptr);

        creationArgs.isPrimary = physical->id == getPrimaryDisplayIdLocked();

        if (useColorManagement) {
            mPhysicalDisplays.get(physical->id)
                    .transform(&PhysicalDisplay::snapshotRef)
                    .transform(ftl::unit_fn([&](const display::DisplaySnapshot& snapshot) {
                        for (const auto mode : snapshot.colorModes()) {
                            creationArgs.hasWideColorGamut |= ui::isWideColorMode(mode);
                            creationArgs.hwcColorModes
                                    .emplace(mode,
                                             getHwComposer().getRenderIntents(physical->id, mode));
                        }
                    }));
        }
    }

    if (const auto id = HalDisplayId::tryCast(compositionDisplay->getId())) {
        getHwComposer().getHdrCapabilities(*id, &creationArgs.hdrCapabilities);
        creationArgs.supportedPerFrameMetadata = getHwComposer().getSupportedPerFrameMetadata(*id);
    }

    // 关注点 1，构建 NativeWindowSurface 对象
    auto nativeWindowSurface = getFactory().createNativeWindowSurface(producer);
    auto nativeWindow = nativeWindowSurface->getNativeWindow();
    creationArgs.nativeWindow = nativeWindow;

    // Make sure that composition can never be stalled by a virtual display
    // consumer that isn't processing buffers fast enough. We have to do this
    // here, in case the display is composed entirely by HWC.
    if (state.isVirtual()) {
        nativeWindow->setSwapInterval(nativeWindow.get(), 0);
    }

    creationArgs.physicalOrientation =
            getPhysicalDisplayOrientation(compositionDisplay->getId(), creationArgs.isPrimary);
    ALOGV("Display Orientation: %s", toCString(creationArgs.physicalOrientation));

    // virtual displays are always considered enabled
    creationArgs.initialPowerMode =
            state.isVirtual() ? std::make_optional(hal::PowerMode::ON) : std::nullopt;

    creationArgs.requestedRefreshRate = state.requestedRefreshRate;

    // 前面的代码都是准备 creationArgs
    // 关注点2
    // Factory 类型是 DefaultFactory，实际就是 new 一个 DisplayDevice
    sp<DisplayDevice> display = getFactory().createDisplayDevice(creationArgs);

    nativeWindowSurface->preallocateBuffers();

    ui::ColorMode defaultColorMode = ui::ColorMode::NATIVE;
    Dataspace defaultDataSpace = Dataspace::UNKNOWN;
    if (display->hasWideColorGamut()) {
        defaultColorMode = ui::ColorMode::SRGB;
        defaultDataSpace = Dataspace::V0_SRGB;
    }
    display->getCompositionDisplay()->setColorProfile(
            compositionengine::Output::ColorProfile{defaultColorMode, defaultDataSpace,
                                                    RenderIntent::COLORIMETRIC,
                                                    Dataspace::UNKNOWN});

    if (const auto& physical = state.physical) {
        mPhysicalDisplays.get(physical->id)
                .transform(&PhysicalDisplay::snapshotRef)
                .transform(ftl::unit_fn([&](const display::DisplaySnapshot& snapshot) {
                    FTL_FAKE_GUARD(kMainThreadContext,
                                   display->setActiveMode(physical->activeMode->getId(),
                                                          physical->activeMode->getFps(),
                                                          physical->activeMode->getFps()));
                }));
    }

    display->setLayerFilter(makeLayerFilterForDisplay(display->getId(), state.layerStack));
    display->setProjection(state.orientation, state.layerStackSpaceRect,
                           state.orientedDisplaySpaceRect);
    display->setDisplayName(state.displayName);
    display->setFlags(state.flags);

    return display;
}

关注点1：

开始的一大堆代码都是用来准备 DisplayDeviceCreationArgs 参数，我们主要关注一下其中的 nativeWindow，它通过 createNativeWindowSurface 函数初始化：

// /frameworks/native/services/surfaceflinger/SurfaceFlingerDefaultFactory.cpp
std::unique_ptr<surfaceflinger::NativeWindowSurface> DefaultFactory::createNativeWindowSurface(
        const sp<IGraphicBufferProducer>& producer) {
    return surfaceflinger::impl::createNativeWindowSurface(producer);
}

1
2
3
4
5

接着调用 impl::createNativeWindowSurface：

// /frameworks/native/services/surfaceflinger/NativeWindowSurface.cpp
std::unique_ptr<surfaceflinger::NativeWindoANativeWindowwSurface> createNativeWindowSurface(
        const sp<IGraphicBufferProducer>& producer) {
    class NativeWindowSurface final : public surfaceflinger::NativeWindowSurface {
    public:
        explicit NativeWindowSurface(const sp<IGraphicBufferProducer>& producer)
              : mSurface(sp<Surface>::make(producer, /* controlledByApp */ false)) {}

        ~NativeWindowSurface() override = default;

        sp<ANativeWindow> getNativeWindow() const override { return mSurface; }

        void preallocateBuffers() override { mSurface->allocateBuffers(); }

    private:
        sp<Surface> mSurface;
    };

    return std::make_unique<NativeWindowSurface>(producer);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

NativeWindowSurface 是一个函数内部类（自己写代码就没用过），继承自 surfaceflinger::NativeWindowSurface。有一个重要成员 mSurface，Surface 是 Producer 的具体持有者，这里会初始化一个 Surface 对象然后赋值给 mSurface 成员，其构造函数实现如下：

Surface::Surface(const sp<IGraphicBufferProducer>& bufferProducer, bool controlledByApp,
                 const sp<IBinder>& surfaceControlHandle)
      : mGraphicBufferProducer(bufferProducer),
        mCrop(Rect::EMPTY_RECT),
        mBufferAge(0),
        mGenerationNumber(0),
        mSharedBufferMode(false),
        mAutoRefresh(false),
        mAutoPrerotation(false),
        mSharedBufferSlot(BufferItem::INVALID_BUFFER_SLOT),
        mSharedBufferHasBeenQueued(false),
        mQueriedSupportedTimestamps(false),
        mFrameTimestampsSupportsPresent(false),
        mEnableFrameTimestamps(false),
        mFrameEventHistory(std::make_unique<ProducerFrameEventHistory>()) {

    // Initialize the ANativeWindow function pointers.
    ANativeWindow::setSwapInterval  = hook_setSwapInterval;
    ANativeWindow::dequeueBuffer    = hook_dequeueBuffer;
    ANativeWindow::cancelBuffer     = hook_cancelBuffer;
    ANativeWindow::queueBuffer      = hook_queueBuffer;
    ANativeWindow::query            = hook_query;
    ANativeWindow::perform          = hook_perform;

    ANativeWindow::dequeueBuffer_DEPRECATED = hook_dequeueBuffer_DEPRECATED;
    ANativeWindow::cancelBuffer_DEPRECATED  = hook_cancelBuffer_DEPRECATED;
    ANativeWindow::lockBuffer_DEPRECATED    = hook_lockBuffer_DEPRECATED;
    ANativeWindow::queueBuffer_DEPRECATED   = hook_queueBuffer_DEPRECATED;

    const_cast<int&>(ANativeWindow::minSwapInterval) = 0;
    const_cast<int&>(ANativeWindow::maxSwapInterval) = 1;

    mReqWidth = 0;
    mReqHeight = 0;
    mReqFormat = 0;
    mReqUsage = 0;
    mTimestamp = NATIVE_WINDOW_TIMESTAMP_AUTO;
    mDataSpace = Dataspace::UNKNOWN;
    mScalingMode = NATIVE_WINDOW_SCALING_MODE_FREEZE;
    mTransform = 0;
    mStickyTransform = 0;
    mDefaultWidth = 0;
    mDefaultHeight = 0;
    mUserWidth = 0;
    mUserHeight = 0;
    mTransformHint = 0;
    mConsumerRunningBehind = false;
    mConnectedToCpu = false;
    mProducerControlledByApp = controlledByApp;
    mSwapIntervalZero = false;
    mMaxBufferCount = NUM_BUFFER_SLOTS;
    mSurfaceControlHandle = surfaceControlHandle;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

Surface 的构造函数就是一堆赋值。

关注点2，会通过工厂模式构建一个 DisplayDevice 对象：

sp<DisplayDevice> DefaultFactory::createDisplayDevice(DisplayDeviceCreationArgs& creationArgs) {
    return sp<DisplayDevice>::make(creationArgs);
}

1
2
3

实际就是 new 一个 DisplayDevice 对象：

DisplayDevice::DisplayDevice(DisplayDeviceCreationArgs& args)
      : mFlinger(args.flinger),
        mHwComposer(args.hwComposer),
        mDisplayToken(args.displayToken),
        mSequenceId(args.sequenceId),
        mCompositionDisplay{args.compositionDisplay},  // Display 成员
        mActiveModeFPSTrace("ActiveModeFPS -" + to_string(getId())),
        mActiveModeFPSHwcTrace("ActiveModeFPS_HWC -" + to_string(getId())),
        mRenderFrameRateFPSTrace("RenderRateFPS -" + to_string(getId())),
        mPhysicalOrientation(args.physicalOrientation),
        mIsPrimary(args.isPrimary),
        mRequestedRefreshRate(args.requestedRefreshRate),
        mRefreshRateSelector(std::move(args.refreshRateSelector)) {

    mCompositionDisplay->editState().isSecure = args.isSecure;
  
    // 初始化 Display 成员的 mRenderSurface 成员
    mCompositionDisplay->createRenderSurface(
            compositionengine::RenderSurfaceCreationArgsBuilder()
                    .setDisplayWidth(ANativeWindow_getWidth(args.nativeWindow.get()))
                    .setDisplayHeight(ANativeWindow_getHeight(args.nativeWindow.get()))
                    .setNativeWindow(std::move(args.nativeWindow))
                    .setDisplaySurface(std::move(args.displaySurface))
                    .setMaxTextureCacheSize(
                            static_cast<size_t>(SurfaceFlinger::maxFrameBufferAcquiredBuffers))
                    .build());

    if (!mFlinger->mDisableClientCompositionCache &&
        SurfaceFlinger::maxFrameBufferAcquiredBuffers > 0) {
        mCompositionDisplay->createClientCompositionCache(
                static_cast<uint32_t>(SurfaceFlinger::maxFrameBufferAcquiredBuffers));
    }

    mCompositionDisplay->setPredictCompositionStrategy(mFlinger->mPredictCompositionStrategy);
    mCompositionDisplay->setTreat170mAsSrgb(mFlinger->mTreat170mAsSrgb);

    mCompositionDisplay->createDisplayColorProfile(
            compositionengine::DisplayColorProfileCreationArgsBuilder()
                    .setHasWideColorGamut(args.hasWideColorGamut)
                    .setHdrCapabilities(std::move(args.hdrCapabilities))
                    .setSupportedPerFrameMetadata(args.supportedPerFrameMetadata)
                    .setHwcColorModes(std::move(args.hwcColorModes))
                    .Build());

    if (!mCompositionDisplay->isValid()) {
        ALOGE("Composition Display did not validate!");
    }

    mCompositionDisplay->getRenderSurface()->initialize();

    if (const auto powerModeOpt = args.initialPowerMode) {
        setPowerMode(*powerModeOpt);
    }

    // initialize the display orientation transform.
    setProjection(ui::ROTATION_0, Rect::INVALID_RECT, Rect::INVALID_RECT);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

构造函数中会调用 createRenderSurface 去构造一个 RenderSurface 对象，调用方是前面构造的 Display 对象：

void Display::createRenderSurface(const RenderSurfaceCreationArgs& args) {
    setRenderSurface(
            compositionengine::impl::createRenderSurface(getCompositionEngine(), *this, args));
}

std::unique_ptr<compositionengine::RenderSurface> createRenderSurface(
        const compositionengine::CompositionEngine& compositionEngine,
        compositionengine::Display& display,
        const compositionengine::RenderSurfaceCreationArgs& args) {
    return std::make_unique<RenderSurface>(compositionEngine, display, args);
}


void Output::setRenderSurface(std::unique_ptr<compositionengine::RenderSurface> surface) {
    mRenderSurface = std::move(surface);
    const auto size = mRenderSurface->getSize();
    editState().framebufferSpace.setBounds(size);
    if (mPlanner) {
        mPlanner->setDisplaySize(size);
    }
    dirtyEntireOutput();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

RenderSurface 构造函数如下：

RenderSurface::RenderSurface(const CompositionEngine& compositionEngine, Display& display,
                             const RenderSurfaceCreationArgs& args)
      : mCompositionEngine(compositionEngine),
        mDisplay(display),
        mNativeWindow(args.nativeWindow), // 这里是前面初始化好的 NativeWindowSurface
        mDisplaySurface(args.displaySurface),
        mSize(args.displayWidth, args.displayHeight),
        mMaxTextureCacheSize(args.maxTextureCacheSize) {
    LOG_ALWAYS_FATAL_IF(!mNativeWindow);
}

1
2
3
4
5
6
7
8
9
10

RenderSurface 会持有前面初始化好的 NativeWindowSurface 对象，NativeWindowSurface 持有 Surface 对象，Surface 对象持有 Producer 对象。所以 RenderSurface 间接持有了 Producer.

client 合成时（先了解一下，后面有分析）：

RenderSurface 间接持有 producer 对象，作为生产者的角色工作，申请 buffer，然后 client 合成 layer，然后把合成结果存在 buffer 中，最后提交 buffer，
FramebufferSurface 持有 comsumer，作为消费者，acquireBuffer 拿到合成好的 buffer，然后通过 setClientTarget 把这个 buffer 传递给 HWC 做处理显示。

# 4. commit 合成数据预处理

本节将对 commit 阶段预处理数据的过程进行详细解析。

# 4.1 回顾：预处理的数据都来自哪里？

commit 预处理合成相关的数据，需要预处理的数据主要来自三个方面：

App 调用 createSurface，创建图层，SurfaceFlinger 进程构建 Layer 对象
App 发起远程事务，配置图层，Transaction
App 通过 Transaction 提交渲染好的 buffer

接下来，我们逐一回顾这些数据的构建过程：

# 4.1.1 App 调用 createSurface

App 端的实现：

tring8 name("displaydemo");
    sp<SurfaceControl> surfaceControl = 
            surfaceComposerClient->createSurface(name, resolution.getWidth(), 
                                                    resolution.getHeight(), PIXEL_FORMAT_RGBA_8888,
                                                    ISurfaceComposerClient::eFXSurfaceBufferState,/*parent*/ nullptr);

1
2
3
4
5

createSurface 的实现如下：

// /frameworks/native/libs/gui/SurfaceComposerClient.cpp

sp<SurfaceControl> SurfaceComposerClient::createSurface(const String8& name, uint32_t w, uint32_t h,
                                                        PixelFormat format, int32_t flags,
                                                        const sp<IBinder>& parentHandle,
                                                        LayerMetadata metadata,
                                                        uint32_t* outTransformHint) {
    sp<SurfaceControl> s;
    createSurfaceChecked(name, w, h, format, &s, flags, parentHandle, std::move(metadata),
                         outTransformHint);
    return s;
}

1
2
3
4
5
6
7
8
9
10
11
12

接着调用 createSurfaceChecked：

// /frameworks/native/libs/gui/SurfaceComposerClient.cpp
status_t SurfaceComposerClient::createSurfaceChecked(const String8& name, uint32_t w, uint32_t h,
                                                     PixelFormat format,
                                                     sp<SurfaceControl>* outSurface, int32_t flags,
                                                     const sp<IBinder>& parentHandle,
                                                     LayerMetadata metadata,
                                                     uint32_t* outTransformHint) {
    sp<SurfaceControl> sur;
    status_t err = mStatus;

    if (mStatus == NO_ERROR) {
        gui::CreateSurfaceResult result;
      
        // 发起远程调用
        // 创建 Layer
        // Layer 相关的信息通过参数 result 返回
        // 重点关注 result 中的 handle 成员
        binder::Status status = mClient->createSurface(std::string(name.string()), flags,
                                                       parentHandle, std::move(metadata), &result);
        err = statusTFromBinderStatus(status);
        if (outTransformHint) {
            *outTransformHint = result.transformHint;
        }
        ALOGE_IF(err, "SurfaceComposerClient::createSurface error %s", strerror(-err));
        if (err == NO_ERROR) {
          
            // 通过 Result 的参数 new 一个 SurfaceControl
            // 重点是 handle
            *outSurface = new SurfaceControl(this, result.handle, result.layerId,
                                             toString(result.layerName), w, h, format,
                                             result.transformHint, flags);
        }
    }
    return err;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

mClient 是匿名 Binder 服务 Client 的代理端对象，这里远程调用到 SurfaceFlinger 进程中的 createSurface 函数，最终会调用到服务端 Client 类的 createSurface 函数中。

// /frameworks/native/services/surfaceflinger/Client.h
sp<SurfaceFlinger> mFlinger;

// /frameworks/native/services/surfaceflinger/Client.cpp
binder::Status Client::createSurface(const std::string& name, int32_t flags,
                                     const sp<IBinder>& parent, const gui::LayerMetadata& metadata,
                                     gui::CreateSurfaceResult* outResult) {

    // We rely on createLayer to check permissions.
    sp<IBinder> handle;
    LayerCreationArgs args(mFlinger.get(), sp<Client>::fromExisting(this), name.c_str(),
                           static_cast<uint32_t>(flags), std::move(metadata));
    // handle 放到了 LayerCreationArgs 中，这个 handle 是我们即将要创建的 Layer 的父 Layer 的索引
    // 需要注意的是 CreateSurfaceResult 中也有一个 handle，这个是我们要创建的 Layer 的索引
    args.parentHandle = parent;
    // 接着调用 SurfaceFlinger 的 createLayer 函数
    const status_t status = mFlinger->createLayer(args, *outResult);
    return binderStatusFromStatusT(status);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

SurfaceFlinger 的 createLayer 函数实现如下：

// /frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

status_t SurfaceFlinger::createLayer(LayerCreationArgs& args, gui::CreateSurfaceResult& outResult) {
    status_t result = NO_ERROR;

    sp<Layer> layer;

    // flags 的值为  ISurfaceComposerClient::eFXSurfaceBufferState
    switch (args.flags & ISurfaceComposerClient::eFXSurfaceMask) {
        case ISurfaceComposerClient::eFXSurfaceBufferQueue:
        case ISurfaceComposerClient::eFXSurfaceContainer:
        case ISurfaceComposerClient::eFXSurfaceBufferState:    // 走这个 case 
            args.flags |= ISurfaceComposerClient::eNoColorFill;  
            FMT_FALLTHROUGH;
        case ISurfaceComposerClient::eFXSurfaceEffect: { // 上面没有 break，这个 case 也会走
            // 关注点 1
            // 创建 Layer 对象
            // args 中有个 handle 
            // 第二个参数也是一个 handle
            result = createBufferStateLayer(args, &outResult.handle, &layer);
            std::atomic<int32_t>* pendingBufferCounter = layer->getPendingBufferCounter();
            if (pendingBufferCounter) {
                std::string counterName = layer->getPendingBufferCounterName();
                mBufferCountTracker.add(outResult.handle->localBinder(), counterName,
                                        pendingBufferCounter);
            }
        } break;
        default:
            result = BAD_VALUE;
            break;
    }

    if (result != NO_ERROR) {
        return result;
    }

    args.addToRoot = args.addToRoot && callingThreadHasUnscopedSurfaceFlingerAccess();
    // We can safely promote the parent layer in binder thread because we have a strong reference
    // to the layer's handle inside this scope.
    // 使用 args.parentHandle 索引找到 Layer 的父节点
    sp<Layer> parent = LayerHandle::getLayer(args.parentHandle.promote());
    if (args.parentHandle != nullptr && parent == nullptr) {
        ALOGE("Invalid parent handle %p", args.parentHandle.promote().get());
        args.addToRoot = false;
    }

    uint32_t outTransformHint;

    // add a layer to SurfaceFlinger
    // 关注点 2
    // 把 Layer 对象添加到 SurfaceFlinger 中去
    result = addClientLayer(args, outResult.handle, layer, parent, &outTransformHint);
    if (result != NO_ERROR) {
        return result;
    }

    outResult.transformHint = static_cast<int32_t>(outTransformHint);
    outResult.layerId = layer->sequence;
    outResult.layerName = String16(layer->getDebugName());
    return result;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

关注点 1 处，通过工厂模式初始化一个 Layer 对象，实际跟进代码就是 new 一个 Layer 对象。

关注点 2 处，把刚 new 的 Layer 对象添加到 SurfaceFlinger 中，具体实现如下：

// /frameworks/native/services/surfaceflinger/SurfaceFlinger.h
    std::vector<LayerCreatedState> mCreatedLayers GUARDED_BY(mCreatedLayersLock);
    std::vector<std::unique_ptr<frontend::RequestedLayerState>> mNewLayers;
    std::vector<LayerCreationArgs> mNewLayerArgs;

// /frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
status_t SurfaceFlinger::addClientLayer(LayerCreationArgs& args, const sp<IBinder>& handle,
                                        const sp<Layer>& layer, const wp<Layer>& parent,
                                        uint32_t* outTransformHint) {

    if (mNumLayers >= MAX_LAYERS) { // Layer 过多的处理
        // ......
    }

    layer->updateTransformHint(mActiveDisplayTransformHint);
    if (outTransformHint) {
        *outTransformHint = mActiveDisplayTransformHint;
    }
    args.parentId = LayerHandle::getLayerId(args.parentHandle.promote());
    args.layerIdToMirror = LayerHandle::getLayerId(args.mirrorLayerHandle.promote());
    {
        std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
        // layer 相关信息放到这里，下次 VSync 信号到来，读取这些数据
        mCreatedLayers.emplace_back(layer, parent, args.addToRoot);
        // 创建 Layer 的参数
        mNewLayers.emplace_back(std::make_unique<frontend::RequestedLayerState>(args));
        args.mirrorLayerHandle.clear();
        args.parentHandle.clear();
        mNewLayerArgs.emplace_back(std::move(args));
    }

    setTransactionFlags(eTransactionNeeded); // 0x01
    return NO_ERROR;   
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

核心就是把创建的 Layer 以及创建过程中的参数保存到 SurfaceFlinger 的 mCreatedLayers mNewLayers mNewLayerArgs 三个成员中。

后续合成过程会使用到这三个参数来构建 Layer 树。

# 4.1.2 App 发起远程事务

App 示例代码中开启了一个事务：

  // 构建事务对象并提交
    SurfaceComposerClient::Transaction{}
            .setLayer(surfaceControl, std::numeric_limits<int32_t>::max())
            .show(surfaceControl)
            .setBackgroundColor(surfaceControl, half3{0, 0, 0}, 1.0f, ui::Dataspace::UNKNOWN) // black background
            .setAlpha(surfaceControl, 1.0f)
            .setLayerStack(surfaceControl, ui::LayerStack::fromValue(mLayerStack))
            .apply();

1
2
3
4
5
6
7
8

这里会先 new 一个 SurfaceComposerClient::Transaction 对象，Transaction 有一个重要的成员 mComposerStates：

    class Transaction : public Parcelable {
        // .....
        std::unordered_map<sp<IBinder>, ComposerState, IBinderHash> mComposerStates;

        std::unordered_map<sp<ITransactionCompletedListener>, CallbackInfo, TCLHash>
                mListenerCallbacks;
        // ......
    }

1
2
3
4
5
6
7
8

mComposerStates 是一个 map，key 是 Layer 的 token, value 是 ComposerState，用于保存 Layer 相关的信息：

class ComposerState {
public:
    layer_state_t state;
    status_t write(Parcel& output) const;
    status_t read(const Parcel& input);
};

1
2
3
4
5
6

layer_state_t 是一个结构体，用于在 SurfaceFlinger 与 app 之间交换 layer 相关的数据。

struct layer_state_t {

// ......
    sp<IBinder> surface;
    int32_t layerId;
    uint64_t what;
    float x;
    float y;
    int32_t z;
    ui::LayerStack layerStack = ui::DEFAULT_LAYER_STACK;
    uint32_t flags;
    uint32_t mask;
    uint8_t reserved;
    matrix22_t matrix;
    float cornerRadius;
    uint32_t backgroundBlurRadius;

    sp<SurfaceControl> relativeLayerSurfaceControl;

    sp<SurfaceControl> parentSurfaceControlForChild;

    half4 color;

    // non POD must be last. see write/read
    Region transparentRegion;
    uint32_t bufferTransform;
    bool transformToDisplayInverse;
    Rect crop;
    std::shared_ptr<BufferData> bufferData = nullptr;
    ui::Dataspace dataspace;
    HdrMetadata hdrMetadata;
    Region surfaceDamageRegion;
    int32_t api;
    sp<NativeHandle> sidebandStream;
    mat4 colorTransform;
    std::vector<BlurRegion> blurRegions;

    sp<gui::WindowInfoHandle> windowInfoHandle = sp<gui::WindowInfoHandle>::make();

    LayerMetadata metadata;

    // The following refer to the alpha, and dataspace, respectively of
    // the background color layer
    half4 bgColor;
    ui::Dataspace bgColorDataspace;
// .....

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

先看 setLayer 的实现：

// /frameworks/native/libs/gui/SurfaceComposerClient.cpp

SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setLayer(
        const sp<SurfaceControl>& sc, int32_t z) {
    layer_state_t* s = getLayerState(sc);
    if (!s) {
        mStatus = BAD_INDEX;
        return *this;
    }
    s->what |= layer_state_t::eLayerChanged;
    s->what &= ~layer_state_t::eRelativeLayerChanged;
    s->z = z;

    registerSurfaceControlForCallback(sc);
    return *this;
}

std::unordered_map<sp<IBinder>, ComposerState, IBinderHash> mComposerStates;

layer_state_t* SurfaceComposerClient::Transaction::getLayerState(const sp<SurfaceControl>& sc) {
  
    // Layer 的 token
    auto handle = sc->getLayerStateHandle();

    if (mComposerStates.count(handle) == 0) {
        // we don't have it, add an initialized layer_state to our list
        ComposerState s;

        s.state.surface = handle;
        s.state.layerId = sc->getLayerId();

        mComposerStates[handle] = s;
    }

    return &(mComposerStates[handle].state);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

实际就是把配置信息写到 mComposerStates 的 layer_state_t state; 成员中。

setPosition 的实现：

SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setPosition(
        const sp<SurfaceControl>& sc, float x, float y) {
    layer_state_t* s = getLayerState(sc);
 
    s->what |= layer_state_t::ePositionChanged;
    s->x = x;
    s->y = y;
 
    return *this;
}

1
2
3
4
5
6
7
8
9
10

别的设置属性的实现基本都差不多，都是把数据存储到 layer_state_t 中，不再一一阐述。数据的关系如下图所示：

20240803140913

设置完一堆参数后，调用 apply 发起远程调用：

// 两个参数默认是 false
status_t SurfaceComposerClient::Transaction::apply(bool synchronous, bool oneWay) {
   // ......
    // 关键
    // 主要数据在 composerStates 中
    sf->setTransactionState(mFrameTimelineInfo, composerStates, displayStates, flags, applyToken,
                            mInputWindowCommands, mDesiredPresentTime, mIsAutoTimestamp,
                            mUncacheBuffers, hasListenerCallbacks, listenerCallbacks, mId,
  
    // .....
    return NO_ERROR;
}

1
2
3
4
5
6
7
8
9
10
11
12

这里 sf->setTransactionState 发起远程调用，最终会 Binder 远程调用到 SurfaceFlinger 的 setTransactionState：

// /frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
status_t SurfaceFlinger::setTransactionState(
        const FrameTimelineInfo& frameTimelineInfo, Vector<ComposerState>& states,
        const Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
        InputWindowCommands inputWindowCommands, int64_t desiredPresentTime, bool isAutoTimestamp,
        const std::vector<client_cache_t>& uncacheBuffers, bool hasListenerCallbacks,
        const std::vector<ListenerCallbacks>& listenerCallbacks, uint64_t transactionId,
        const std::vector<uint64_t>& mergedTransactionIds) {
   

    // ......

    // 关注点1
    // ComposerState 转换为 ResolvedComposerState
    std::vector<ResolvedComposerState> resolvedStates;
    resolvedStates.reserve(states.size());
    for (auto& state : states) {
        resolvedStates.emplace_back(std::move(state));
        auto& resolvedState = resolvedStates.back();
        if (resolvedState.state.hasBufferChanges() && resolvedState.state.hasValidBuffer() &&
            resolvedState.state.surface) {
            sp<Layer> layer = LayerHandle::getLayer(resolvedState.state.surface);
            std::string layerName = (layer) ?
                    layer->getDebugName() : std::to_string(resolvedState.state.layerId);
            resolvedState.externalTexture =
                    getExternalTextureFromBufferData(*resolvedState.state.bufferData,
                                                     layerName.c_str(), transactionId);
            mBufferCountTracker.increment(resolvedState.state.surface->localBinder());
        }
        resolvedState.layerId = LayerHandle::getLayerId(resolvedState.state.surface);
        if (resolvedState.state.what & layer_state_t::eReparent) {
            resolvedState.parentId =
                    getLayerIdFromSurfaceControl(resolvedState.state.parentSurfaceControlForChild);
        }
        if (resolvedState.state.what & layer_state_t::eRelativeLayerChanged) {
            resolvedState.relativeParentId =
                    getLayerIdFromSurfaceControl(resolvedState.state.relativeLayerSurfaceControl);
        }
        if (resolvedState.state.what & layer_state_t::eInputInfoChanged) {
            wp<IBinder>& touchableRegionCropHandle =
                    resolvedState.state.windowInfoHandle->editInfo()->touchableRegionCropHandle;
            resolvedState.touchCropId =
                    LayerHandle::getLayerId(touchableRegionCropHandle.promote());
        }
    }

    // 关注点 2
    // 构建一个 TransactionState
    TransactionState state{frameTimelineInfo,
                           resolvedStates,
                           displays,
                           flags,
                           applyToken,
                           std::move(inputWindowCommands),
                           desiredPresentTime,
                           isAutoTimestamp,
                           std::move(uncacheBufferIds),
                           postTime,
                           hasListenerCallbacks,
                           listenerCallbacks,
                           originPid,
                           originUid,
                           transactionId,
                           mergedTransactionIds};


    if (mTransactionTracing) {
        mTransactionTracing->addQueuedTransaction(state);
    }

    const auto schedule = [](uint32_t flags) {
        if (flags & eEarlyWakeupEnd) return TransactionSchedule::EarlyEnd;
        if (flags & eEarlyWakeupStart) return TransactionSchedule::EarlyStart;
        return TransactionSchedule::Late;
    }(state.flags);

    // 关注点3
    const auto frameHint = state.isFrameActive() ? FrameHint::kActive : FrameHint::kNone;
    mTransactionHandler.queueTransaction(std::move(state));
    setTransactionFlags(eTransactionFlushNeeded, schedule, applyToken, frameHint);
    return NO_ERROR;
}

关注点 1，将参数传入的 ComposerState 转换为 ResolvedComposerState 关注点 2，通过传入的参数构建一个 TransactionState 对象。关注点 3，将 TransactionState 对象保存在 mTransactionHandler 的 mLocklessTransactionQueue 成员中。

看下关注点3 的实现：

// /frameworks/native/services/surfaceflinger/FrontEnd/TransactionHandler.h
LocklessQueue<TransactionState> mLocklessTransactionQueue;

// /frameworks/native/services/surfaceflinger/FrontEnd/TransactionHandler.cpp
void TransactionHandler::queueTransaction(TransactionState&& state) {
    mLocklessTransactionQueue.push(std::move(state));
    mPendingTransactionCount.fetch_add(1);
    ATRACE_INT("TransactionQueue", static_cast<int>(mPendingTransactionCount.load()));
}

1
2
3
4
5
6
7
8
9

小结：事务对象的成员经过简单的处理，构建为 TransactionState 对象并保存在 mLocklessTransactionQueue 中。

# 4.1.3 App 提交渲染好的 buffer

前面我们分析过，App 端渲染好 buffer 以后，会通过层层的回调调用到 acquireNextBufferLocked 函数：

status_t BLASTBufferQueue::acquireNextBufferLocked(
        const std::optional<SurfaceComposerClient::Transaction*> transaction) {
   
    //......

    // 准备事务对象 Transaction
    SurfaceComposerClient::Transaction localTransaction;
    bool applyTransaction = true;
    SurfaceComposerClient::Transaction* t = &localTransaction;
    if (transaction) {
        t = *transaction;
        applyTransaction = false;
    }

    // 调用 acquireBuffer 函数 从队列中获取到一个 BufferItem 对象
    BufferItem bufferItem;

    // 关注点1
    status_t status =
            mBufferItemConsumer->acquireBuffer(&bufferItem, 0 /* expectedPresent */, false);
  
    //......

    auto buffer = bufferItem.mGraphicBuffer;
    mNumFrameAvailable--;
  
    // ......

    mNumAcquired++;
    mLastAcquiredFrameNumber = bufferItem.mFrameNumber;
    ReleaseCallbackId releaseCallbackId(buffer->getId(), mLastAcquiredFrameNumber);
    mSubmitted[releaseCallbackId] = bufferItem;

    bool needsDisconnect = false;
    mBufferItemConsumer->getConnectionEvents(bufferItem.mFrameNumber, &needsDisconnect);

    // if producer disconnected before, notify SurfaceFlinger
    if (needsDisconnect) {
        t->notifyProducerDisconnect(mSurfaceControl);
    }

    // Ensure BLASTBufferQueue stays alive until we receive the transaction complete callback.
    incStrong((void*)transactionCallbackThunk);

    // Only update mSize for destination bounds if the incoming buffer matches the requested size.
    // Otherwise, it could cause stretching since the destination bounds will update before the
    // buffer with the new size is acquired.
    if (mRequestedSize == getBufferSize(bufferItem) ||
        bufferItem.mScalingMode != NATIVE_WINDOW_SCALING_MODE_FREEZE) {
        mSize = mRequestedSize;
    }
    Rect crop = computeCrop(bufferItem);
    mLastBufferInfo.update(true /* hasBuffer */, bufferItem.mGraphicBuffer->getWidth(),
                           bufferItem.mGraphicBuffer->getHeight(), bufferItem.mTransform,
                           bufferItem.mScalingMode, crop);

    // 构造一个回调对象
    auto releaseBufferCallback =
            std::bind(releaseBufferCallbackThunk, wp<BLASTBufferQueue>(this) /* callbackContext */,
                      std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
  
    // 这里会同时拿到 bufferItem 中的 fence 对象
    sp<Fence> fence = bufferItem.mFence ? new Fence(bufferItem.mFence->dup()) : Fence::NO_FENCE;
    // t 是准备提交给 SurfaceFlinger 的事务对象
    // 根据 bufferItem 来配置

    // 关注点2
    // 注意这里传入了回调对象
    t->setBuffer(mSurfaceControl, buffer, fence, bufferItem.mFrameNumber, mProducerId,
                 releaseBufferCallback);
    t->setDataspace(mSurfaceControl, static_cast<ui::Dataspace>(bufferItem.mDataSpace));
    t->setHdrMetadata(mSurfaceControl, bufferItem.mHdrMetadata);
    t->setSurfaceDamageRegion(mSurfaceControl, bufferItem.mSurfaceDamage);
    t->addTransactionCompletedCallback(transactionCallbackThunk, static_cast<void*>(this));

    mSurfaceControlsWithPendingCallback.push(mSurfaceControl);

    if (mUpdateDestinationFrame) {
        t->setDestinationFrame(mSurfaceControl, Rect(mSize));
    } else {
        const bool ignoreDestinationFrame =
                bufferItem.mScalingMode == NATIVE_WINDOW_SCALING_MODE_FREEZE;
        t->setFlags(mSurfaceControl,
                    ignoreDestinationFrame ? layer_state_t::eIgnoreDestinationFrame : 0,
                    layer_state_t::eIgnoreDestinationFrame);
    }
    t->setBufferCrop(mSurfaceControl, crop);
    t->setTransform(mSurfaceControl, bufferItem.mTransform);
    t->setTransformToDisplayInverse(mSurfaceControl, bufferItem.mTransformToDisplayInverse);
    t->setAutoRefresh(mSurfaceControl, bufferItem.mAutoRefresh);
    if (!bufferItem.mIsAutoTimestamp) {
        t->setDesiredPresentTime(bufferItem.mTimestamp);
    }

    // Drop stale frame timeline infos
    while (!mPendingFrameTimelines.empty() &&
           mPendingFrameTimelines.front().first < bufferItem.mFrameNumber) {
        ATRACE_FORMAT_INSTANT("dropping stale frameNumber: %" PRIu64 " vsyncId: %" PRId64,
                              mPendingFrameTimelines.front().first,
                              mPendingFrameTimelines.front().second.vsyncId);
        mPendingFrameTimelines.pop();
    }

    if (!mPendingFrameTimelines.empty() &&
        mPendingFrameTimelines.front().first == bufferItem.mFrameNumber) {
        ATRACE_FORMAT_INSTANT("Transaction::setFrameTimelineInfo frameNumber: %" PRIu64
                              " vsyncId: %" PRId64,
                              bufferItem.mFrameNumber,
                              mPendingFrameTimelines.front().second.vsyncId);
        t->setFrameTimelineInfo(mPendingFrameTimelines.front().second);
        mPendingFrameTimelines.pop();
    }

    {
        std::lock_guard _lock{mTimestampMutex};
        auto dequeueTime = mDequeueTimestamps.find(buffer->getId());
        if (dequeueTime != mDequeueTimestamps.end()) {
            Parcel p;
            p.writeInt64(dequeueTime->second);
            t->setMetadata(mSurfaceControl, gui::METADATA_DEQUEUE_TIME, p);
            mDequeueTimestamps.erase(dequeueTime);
        }
    }

    mergePendingTransactions(t, bufferItem.mFrameNumber);
    if (applyTransaction) { // 进入分支
        // All transactions on our apply token are one-way. See comment on mAppliedLastTransaction
        // 关注点 3
        // 提交事务
        t->setApplyToken(mApplyToken).apply(false, true);
        mAppliedLastTransaction = true;
        mLastAppliedFrameNumber = bufferItem.mFrameNumber;
    } else {
        // 设置 barrier
        t->setBufferHasBarrier(mSurfaceControl, mLastAppliedFrameNumber);
        mAppliedLastTransaction = false;
    }

    BQA_LOGV("acquireNextBufferLocked size=%dx%d mFrameNumber=%" PRIu64
             " applyTransaction=%s mTimestamp=%" PRId64 "%s mPendingTransactions.size=%d"
             " graphicBufferId=%" PRIu64 "%s transform=%d",
             mSize.width, mSize.height, bufferItem.mFrameNumber, boolToString(applyTransaction),
             bufferItem.mTimestamp, bufferItem.mIsAutoTimestamp ? "(auto)" : "",
             static_cast<uint32_t>(mPendingTransactions.size()), bufferItem.mGraphicBuffer->getId(),
             bufferItem.mAutoRefresh ? " mAutoRefresh" : "", bufferItem.mTransform);
    return OK;
}

关注点 1，调用 acquireBuffer 获取到 BufferItem 关注点 2，构建事务对象 Transaction 关注点 3，apply 提交事务对象

apply 部分和上一小节一样，提交的事务对象最终会转换为 TransactionState 对象并保存在 mLocklessTransactionQueue 中。流程都是一样的，就不再分析了。差异主要是在构建的 Transaction 对象上。

# 4.2 commit 处理数据过程分析

commit 执行之前，以下的数据们都准备好了：

SurfaceFlinger 对象中的 LayerCreatedState 成员：

std::vector<LayerCreatedState> mCreatedLayers

SurfaceFlinger 中有一个成员 TransactionHandler，它有一个 mLocklessTransactionQueue 成员：

LocklessQueue<TransactionState> mLocklessTransactionQueue;

提交的配置事务，渲染好的 buffer 都保存在里面。

接下来我们来看 commit 的具体实现：

bool SurfaceFlinger::commit(TimePoint frameTime, VsyncId vsyncId, TimePoint expectedVsyncTime)
        FTL_FAKE_GUARD(kMainThreadContext) {

    // ......

    bool mustComposite = mMustComposite.exchange(false);
    {
        mFrameTimeline->setSfWakeUp(vsyncId.value, frameTime.ns(),
                                    Fps::fromPeriodNsecs(vsyncPeriod.ns()));


        const bool flushTransactions = clearTransactionFlags(eTransactionFlushNeeded);

        // 预处理后的信息放到一个结构体 Update 中
        frontend::Update updates;
        if (flushTransactions) {
            // 关注点1
            updates = flushLifecycleUpdates();
            //tracing
        }
        bool transactionsAreEmpty;
        // mLegacyFrontEndEnabled和mLayerLifecycleManagerEnabled只有一个为ture，
        // 应该是两套算法逻辑，会根据一个系统属性来决定，都是更新layer中的Snapshot的
        // 因为我看我的手机的属性应该是走的mLegacyFrontEndEnabled true的逻辑，我们这里就看这条线
        if (mLegacyFrontEndEnabled) {
            // 关注点 2
            mustComposite |= updateLayerSnapshotsLegacy(vsyncId, updates, flushTransactions,
                                                        transactionsAreEmpty);
        }
        if (mLayerLifecycleManagerEnabled) {
            mustComposite |=
                    updateLayerSnapshots(vsyncId, updates, flushTransactions, transactionsAreEmpty);
        }

        if (transactionFlushNeeded()) {
            setTransactionFlags(eTransactionFlushNeeded);
        }

        // 回调通知,在releasePendingBuffer时候，会addCallbackHandles，然后这里会回调client侧，然后client进行BufferRelease
        if (transactionsAreEmpty) {
            mTransactionCallbackInvoker.sendCallbacks(false /* onCommitOnly */);
        } else {
            mTransactionCallbackInvoker.sendCallbacks(true /* onCommitOnly */);
        }
    }

    // 处理刷新率更新
    {
        Mutex::Autolock lock(mStateLock);
        mScheduler->chooseRefreshRateForContent();
        setActiveModeInHwcIfNeeded();
    }

    updateCursorAsync();
    // 更新inputFlinger focused窗口
    updateInputFlinger(vsyncId, frameTime);
    // 。。。

    persistDisplayBrightness(mustComposite);
    // 返回是否需要合成
    return mustComposite && CC_LIKELY(mBootStage != BootStage::BOOTLOADER);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

代码非常多，我们主要关注两点：

关注点 1， flushLifecycleUpdates：Layer 相关数据收集
关注点2，updateLayerSnapshotsLegacy：Layer 相关数据基本处理

# 4.2.1 flushLifecycleUpdates 数据处理过程分析

flushLifecycleUpdates 的实现如下：


struct Update {
    std::vector<TransactionState> transactions;

    std::vector<LayerCreatedState> layerCreatedStates;
  
    std::vector<std::unique_ptr<frontend::RequestedLayerState>> newLayers;
  
    std::vector<LayerCreationArgs> layerCreationArgs;
  
    std::vector<uint32_t> destroyedHandles;
};

frontend::Update SurfaceFlinger::flushLifecycleUpdates() {
    frontend::Update update;
    // 处理之前 setTransactionState 放入队列的任务
    // 会把所有 Ready 状态的 TransactionState 返回回来，然后存在 update.transactions
    update.transactions = mTransactionHandler.flushTransactions();
  
    {
        // 当client侧通过binder请求SurfaceFlinger，SurfaceFlinger会将参数放到mNewLayers，mCreatedLayers里
        // 这里会把参数都提取出来，全部都放到Update里面
        std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
        update.layerCreatedStates = std::move(mCreatedLayers);
        mCreatedLayers.clear();
        update.newLayers = std::move(mNewLayers);
        mNewLayers.clear();
        update.layerCreationArgs = std::move(mNewLayerArgs);
        mNewLayerArgs.clear();
        update.destroyedHandles = std::move(mDestroyedHandles);
        mDestroyedHandles.clear();
    }
    return update;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

flushTransactions 用于过滤 mLocklessTransactionQueue 中的数据
接着把 mCreatedLayers mNewLayers mNewLayerArgs mDestroyedHandles 这些成员保存到 Update 对象中，这些数据主要来自 App 端，Surface 的添加或者删除

接下来来看 flushTransactions() 如何过滤数据：


LocklessQueue<TransactionState> mLocklessTransactionQueue;

std::unordered_map<sp<IBinder>, std::queue<TransactionState>, IListenerHash> mPendingTransactionQueues;

std::vector<TransactionState> TransactionHandler::flushTransactions() {

    // 关注点1
    // 第一次筛选  mLocklessTransactionQueue -> mPendingTransactionQueues
    while (!mLocklessTransactionQueue.isEmpty()) {
        // 之前讲 Transaction 到章节最后我们提到，Transaction 里面的内容被封装成 TransactionState，通过 queueTransaction 放到队列中
        // 就是放在了 mLocklessTransactionQueue 中
        // 这里取出来的就是 TransactionState
        auto maybeTransaction = mLocklessTransactionQueue.pop();
        // 过滤异常的 State
        if (!maybeTransaction.has_value()) {
            break;
        }
        auto transaction = maybeTransaction.value();
        // 把有效的 TransactionState 放到 mPendingTransactionQueues 中。
        mPendingTransactionQueues[transaction.applyToken].emplace(std::move(transaction));
    }

    std::vector<TransactionState> transactions;
    TransactionFlushState flushState;
    flushState.queueProcessTime = systemTime();
    // 循环执行 flushPendingTransactionQueues，这里需要循环的原因上面已经说了，主要是处理有 barrier 的 Transaction。
    int lastTransactionsPendingBarrier = 0;
    int transactionsPendingBarrier = 0;

    // 关注点2
    // 第二次筛选 mPendingTransactionQueues -> transactions
    // 直到两次 flushPendingTransactionQueues 的返回值相同才跳出循环
    do {
        // 这里比较两次flushPendingTransactionQueues后由于barrier未就绪的Transaction个数，如果一样说明不需要再继续执行flushPendingTransactionQueues
        lastTransactionsPendingBarrier = transactionsPendingBarrier;
        // 会把所有ready状态的TransactionState存储到transactions
        transactionsPendingBarrier = flushPendingTransactionQueues(transactions, flushState);
    } while (lastTransactionsPendingBarrier != transactionsPendingBarrier);

    applyUnsignaledBufferTransaction(transactions, flushState);

    mPendingTransactionCount.fetch_sub(transactions.size());
    ATRACE_INT("TransactionQueue", static_cast<int>(mPendingTransactionCount.load()));
    return transactions;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

关注点 1，遍历 mLocklessTransactionQueue 中保存的 TransactionState，剔除没有数据的，剩余的数据保存到 mPendingTransactionQueues 中
关注点 2，调用 flushPendingTransactionQueues，进一步筛选 TransactionState，筛选后符合要求的数据会被保存在参数 transactions 中。

关注点 2 处比较特别的是，循环调用了 flushPendingTransactionQueues，flushPendingTransactionQueues 本身就会遍历所有的 TransactionState，这里之所以还要加一个循环是因为有屏障逻辑。是因为在 acquireNextBufferLocked 的时候如果没有立刻将 Transaction 传给 SurfaceFlinger 的情况，就会设置一个 barrier，表示新的这个 Transaction 的处理必须要依赖上一个 Transaction 的完成。

status_t BLASTBufferQueue::acquireNextBufferLocked(
        const std::optional<SurfaceComposerClient::Transaction*> transaction) {
   
    //......

    // 准备事务对象 Transaction
    SurfaceComposerClient::Transaction localTransaction;
    bool applyTransaction = true;
    SurfaceComposerClient::Transaction* t = &localTransaction;
    if (transaction) {
        t = *transaction;
        applyTransaction = false;
    }

    // ......
    if (applyTransaction) { 
     
        t->setApplyToken(mApplyToken).apply(false, true);
        mAppliedLastTransaction = true;
        mLastAppliedFrameNumber = bufferItem.mFrameNumber;
    } else { // 参数 transaction 不为空
        // 关注点：设置 barrier，且没有 apply
        t->setBufferHasBarrier(mSurfaceControl, mLastAppliedFrameNumber);
        mAppliedLastTransaction = false;
    }

    BQA_LOGV("acquireNextBufferLocked size=%dx%d mFrameNumber=%" PRIu64
             " applyTransaction=%s mTimestamp=%" PRId64 "%s mPendingTransactions.size=%d"
             " graphicBufferId=%" PRIu64 "%s transform=%d",
             mSize.width, mSize.height, bufferItem.mFrameNumber, boolToString(applyTransaction),
             bufferItem.mTimestamp, bufferItem.mIsAutoTimestamp ? "(auto)" : "",
             static_cast<uint32_t>(mPendingTransactions.size()), bufferItem.mGraphicBuffer->getId(),
             bufferItem.mAutoRefresh ? " mAutoRefresh" : "", bufferItem.mTransform);
    return OK;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

接着我们来看 flushPendingTransactionQueues 的实现：

int TransactionHandler::flushPendingTransactionQueues(std::vector<TransactionState>& transactions, TransactionFlushState& flushState) {

        int transactionsPendingBarrier = 0;
        // 遍历所有 TransactionState
        auto it = mPendingTransactionQueues.begin();
        while (it != mPendingTransactionQueues.end()) {
            auto& [applyToken, queue] = *it;
            while (!queue.empty()) {
                auto& transaction = queue.front();
                flushState.transaction = &transaction;
                // 判断Transaction当前是否ready，比如有barrier的，依赖的前置Transaction是否已经执行了
                // 或者是期望的时间还没有到
                auto ready = applyFilters(flushState);
                if (ready == TransactionReadiness::NotReadyBarrier) {
                    // 统计barrier没有就绪的个数，如果两次循环执行flushPendingTransactionQueues这个数量未改变，
                    // 就不用再继续循环了，需要等下一帧再处理
                    transactionsPendingBarrier++;
                    break;
                } else if (ready == TransactionReadiness::NotReady) {
                    break;
                } else if (ready == TransactionReadiness::NotReadyUnsignaled) {
                    flushState.queueWithUnsignaledBuffer = applyToken;
                    break;
                }
                // 走到这的Transaction就是已经处于ready状态了
                popTransactionFromPending(transactions, flushState, queue);
            }

            if (queue.empty()) {
                it = mPendingTransactionQueues.erase(it);
            } else {
                it = std::next(it, 1);
            }
        }
        // 返回由于barrier未就绪导致未处理的Transcaion个数
        return transactionsPendingBarrier;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

通过 applyFilters 逐个判断 TrasactionState 是否 ready，主要是判断两个点：

1.时间，通过 SurfaceFlinger::transactionReadyTimelineCheck 判断 2.barrier 是否就绪，通过 SurfaceFlinger::transactionReadyBufferCheck 判断

applyFilters：

TransactionHandler::TransactionReadiness TransactionHandler::applyFilters(
        TransactionFlushState& flushState) {
    auto ready = TransactionReadiness::Ready;
    for (auto& filter : mTransactionReadyFilters) {
        auto perFilterReady = filter(flushState);
        switch (perFilterReady) {
            case TransactionReadiness::NotReady:
            case TransactionReadiness::NotReadyBarrier:
                return perFilterReady;

            case TransactionReadiness::NotReadyUnsignaled:
                // If one of the filters allows latching an unsignaled buffer, latch this ready
                // state.
                ready = perFilterReady;
                break;
            case TransactionReadiness::Ready:
                continue;
        }
    }
    return ready;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

mTransactionReadyFilters 什么时候初始化？

// /frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
void SurfaceFlinger::init() FTL_FAKE_GUARD(kMainThreadContext) {
    ALOGI(  "SurfaceFlinger's main thread ready to run. "
            "Initializing graphics H/W...");
    addTransactionReadyFilters();
    Mutex::Autolock lock(mStateLock);
    //......
}

void SurfaceFlinger::addTransactionReadyFilters() {
    mTransactionHandler.addTransactionReadyFilter(
            std::bind(&SurfaceFlinger::transactionReadyTimelineCheck, this, std::placeholders::_1));
    mTransactionHandler.addTransactionReadyFilter(
            std::bind(&SurfaceFlinger::transactionReadyBufferCheck, this, std::placeholders::_1));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

// /frameworks/native/services/surfaceflinger/FrontEnd/TransactionHandler.cpp
void TransactionHandler::addTransactionReadyFilter(TransactionFilter&& filter) {
    mTransactionReadyFilters.emplace_back(std::move(filter));
}

1
2
3
4

所以这里有两个回调是 SurfaceFlinger::transactionReadyTimelineCheck 和 SurfaceFlinger::transactionReadyBufferCheck。

经过两个回调的处理，TransactionState 就符合要求了，接着调用 popTransactionFromPending 将 ready 的 TransactionState 存到 transactions 集合中。

void TransactionHandler::popTransactionFromPending(std::vector<TransactionState>& transactions,
                                                TransactionFlushState& flushState,
                                                std::queue<TransactionState>& queue) {
    auto& transaction = queue.front();
    // Transaction is ready move it from the pending queue.
    flushState.firstTransaction = false;
    removeFromStalledTransactions(transaction.id);
    // 将TransactionState加到transactions队列里。
    transactions.emplace_back(std::move(transaction));
    queue.pop();

    auto& readyToApplyTransaction = transactions.back();
    readyToApplyTransaction.traverseStatesWithBuffers([&](const layer_state_t& state) {
        const bool frameNumberChanged =
                state.bufferData->flags.test(BufferData::BufferDataChange::frameNumberChanged);
        // bufferLayersReadyToPresent是一个map，key是窗口的handle，value是帧号。
        if (frameNumberChanged) {
            flushState.bufferLayersReadyToPresent.emplace_or_replace(state.surface.get(),
                                                                    state.bufferData->frameNumber);
        } else {
            flushState.bufferLayersReadyToPresent
                    .emplace_or_replace(state.surface.get(), std::numeric_limits<uint64_t>::max());
        }
    });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

层层返回以后，最后符合要求的 TransactionState 都保存在了 update.transactions 中。

# 4.2.2 updateLayerSnapshotsLegacy 数据处理过程分析

bool SurfaceFlinger::updateLayerSnapshotsLegacy(VsyncId vsyncId, frontend::Update& update,
                                                bool transactionsFlushed,
                                                bool& outTransactionsAreEmpty) {
    bool needsTraversal = false;
    if (transactionsFlushed) {
        // 其他进程通过mirrorDisplay请求SurfaceFlinger创建镜像屏，就在这里处理，一般mirror屏幕用于录屏之类
        // 这里主要做的就是会创建一套和原来一模一样结构的layer树结构，名字后面会带mirror后缀。细节就不详细看了，感兴趣的可以自己看一下
        needsTraversal |= commitMirrorDisplays(vsyncId);
        // 处理创建layer相关的任务，如果有新增的layer返回true
        needsTraversal |= commitCreatedLayers(vsyncId, update.layerCreatedStates);
        // 处理TransactionState
        needsTraversal |= applyTransactions(update.transactions, vsyncId);
    }

    outTransactionsAreEmpty = !needsTraversal;
    const bool shouldCommit = (getTransactionFlags() & ~eTransactionFlushNeeded) || needsTraversal;
    if (shouldCommit) {
        // 关键是处理 buffer 相关的信息
        commitTransactions();
    }
    // latchBuffers
    bool mustComposite = latchBuffers() || shouldCommit;
    updateLayerGeometry();
    return mustComposite;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

updateLayerSnapshotsLegacy 会进一步处理，App 那边传递过来的数据，我们主要关注以下几点：

调用 commitCreatedLayers 处理添加 layer 的请求
调用 applyTransactions 处理通过 Transactions 请求 layer 的属性变化
调用 commitTransactions，处理一些存储在 pending 变量里的 layer 增删旋转等操作，还会将我们前面存储在临时变量的属性（比如 mCurrentState）同步到当前使用的属性中去（比如mDrawingState）
调用了 latchBuffers 去获取了所有新的 buffer（如果layer有内容更新则需要获取新buffer），存到 BufferInfo 中。

先看 commitCreatedLayers 的实现：

bool SurfaceFlinger::commitCreatedLayers(VsyncId vsyncId,
                                        std::vector<LayerCreatedState>& createdLayers) {
    if (createdLayers.size() == 0) {
        return false;
    }

    Mutex::Autolock _l(mStateLock);
    for (const auto& createdLayer : createdLayers) {
        // 遍历所有新建的 layer，调用 handleLayerCreatedLocked 来做添加操作
        handleLayerCreatedLocked(createdLayer, vsyncId);
    }
    mLayersAdded = true;
    return mLayersAdded;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

遍历 createdLayers，调用 handleLayerCreatedLocked 做实际的添加操作：


struct LayerCreatedState {
    LayerCreatedState(const wp<Layer>& layer, const wp<Layer>& parent, bool addToRoot)
          : layer(layer), initialParent(parent), addToRoot(addToRoot) {}
    wp<Layer> layer;
    // Indicates the initial parent of the created layer, only used for creating layer in
    // SurfaceFlinger. If nullptr, it may add the created layer into the current root layers.
    wp<Layer> initialParent;
    // Indicates whether the layer getting created should be added at root if there's no parent
    // and has permission ACCESS_SURFACE_FLINGER. If set to false and no parent, the layer will
    // be added offscreen.
    bool addToRoot;
};

void SurfaceFlinger::handleLayerCreatedLocked(const LayerCreatedState& state, VsyncId vsyncId) {
    // ...... 检查LayerCreatedState里的layer是否有效

    // 获取 state 的 initialParent，存放在 parent
    sp<Layer> parent;
    bool addToRoot = state.addToRoot;
    if (state.initialParent != nullptr) {
        parent = state.initialParent.promote();
        if (parent == nullptr) {
            ALOGD("Parent was destroyed soon after creation %p", state.initialParent.unsafe_get());
            addToRoot = false;
        }
    }
    // 如果有parent就通过addChild添加到layer树内，如果是root节点，添加到mCurrentState.layersSortedByZ数组。
    if (parent == nullptr && addToRoot) {
        layer->setIsAtRoot(true);
        mCurrentState.layersSortedByZ.add(layer);
    } else if (parent == nullptr) {
        layer->onRemovedFromCurrentState();
    } else if (parent->isRemovedFromCurrentState()) {
        parent->addChild(layer);
        layer->onRemovedFromCurrentState();
    } else {
        parent->addChild(layer);
    }

    // layerStack 我们在 Transaction 章节有提过，他代表 layer 显示在哪个屏幕上。
    ui::LayerStack layerStack = layer->getLayerStack(LayerVector::StateSet::Current);
    sp<const DisplayDevice> hintDisplay; // layer 应该显示的屏幕
    // 这里根据layerStack找到对应的屏幕
    for (const auto& [token, display] : mDisplays) {
        if (display->getLayerStack() == layerStack) {
            hintDisplay = display;
            break;
        }
    }
    // 给 layer 设置屏幕的 Transform 配置(旋转状况)
    if (hintDisplay) {
        layer->updateTransformHint(hintDisplay->getTransformHint());
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

handleLayerCreatedLocked 中，会根据 LayerCreatedState 的参数，将 layer 添加到 layer 树上。如果是根节点，就添加到 mCurrentState.layersSortedByZ，否则就找到对应的父节点，然后通过 addChild 添加。最后会根据 layerStack 获取对应的 display，根据屏幕的旋转状态通过 updateTransformHint 给 layer 设置旋转状态。

接着再看 applyTransactions 函数的实现：

bool SurfaceFlinger::applyTransactions(std::vector<TransactionState>& transactions,
                                    VsyncId vsyncId) {
    Mutex::Autolock lock(mStateLock);
    return applyTransactionsLocked(transactions, vsyncId);
}

1
2
3
4
5

加锁后，接着调用 applyTransactionsLocked：

bool SurfaceFlinger::applyTransactionsLocked(std::vector<TransactionState>& transactions,
                                         VsyncId vsyncId) {
    bool needsTraversal = false;
    // Now apply all transactions.
    for (auto& transaction : transactions) {
        // 每个 Transaction 都调用 applyTransactionState
        needsTraversal |=
                applyTransactionState(transaction.frameTimelineInfo, transaction.states,
                                    transaction.displays, transaction.flags,
                                    transaction.inputWindowCommands,
                                    transaction.desiredPresentTime, transaction.isAutoTimestamp,
                                    std::move(transaction.uncacheBufferIds), transaction.postTime,
                                    transaction.hasListenerCallbacks,
                                    transaction.listenerCallbacks, transaction.originPid,
                                    transaction.originUid, transaction.id);
    }
    return needsTraversal;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

applyTransactionsLocked 就是遍历所有 TransactionState ，然后调用 applyTransactionState 函数并传入 TransactionState 的各个成员。

applyTransactionState 的实现如下：

bool SurfaceFlinger::applyTransactionState(const FrameTimelineInfo& frameTimelineInfo,
                                        std::vector<ResolvedComposerState>& states,
                                        Vector<DisplayState>& displays, uint32_t flags,
                                        const InputWindowCommands& inputWindowCommands,
                                        const int64_t desiredPresentTime, bool isAutoTimestamp,
                                        const std::vector<uint64_t>& uncacheBufferIds,
                                        const int64_t postTime, bool hasListenerCallbacks,
                                        const std::vector<ListenerCallbacks>& listenerCallbacks,
                                        int originPid, int originUid, uint64_t transactionId) {

    uint32_t transactionFlags = 0;

    // 处理 displays
    // displays 和 mCurrentState 里面的 displays 对比，如果有变化就更新，标记 flag 的 eDisplayTransactionNeeded 位。
    if (!mLayerLifecycleManagerEnabled) {
        for (DisplayState& display : displays) {
            transactionFlags |= setDisplayStateLocked(display);
        }
    }

    for (const auto& listener : listenerCallbacks) {
        mTransactionCallbackInvoker.addEmptyTransaction(listener);
    }

    uint32_t clientStateFlags = 0;
    for (auto& resolvedState : states) {
        // 我们看 mLegacyFrontEndEnabled 为 true 的这个逻辑
        // 这个参数的值来自系统配置，我手上的 pixel6 是 true
        if (mLegacyFrontEndEnabled) {
            // 根据ResolvedComposerState更新layer，这里主要就是通过layer_state_t的what标识位判断需要更新的变量，然后更新layer里面的变量
            // 如果更新了layer的变量就会返回相关的flag，几乎都有eTraversalNeeded。
            clientStateFlags |=
                    setClientStateLocked(frameTimelineInfo, resolvedState, desiredPresentTime,
                                        isAutoTimestamp, postTime, transactionId);

        } else /*mLayerLifecycleManagerEnabled*/ {
            clientStateFlags |= updateLayerCallbacksAndStats(frameTimelineInfo, resolvedState,
                                                            desiredPresentTime, isAutoTimestamp,
                                                            postTime, transactionId);
        }

        // 如果是执行动画过程，调用 recordLayerHistoryAnimationTx 记录一些属性。（用于选择刷新率）
        if ((flags & eAnimation) && resolvedState.state.surface) {
            if (const auto layer = LayerHandle::getLayer(resolvedState.state.surface)) {
                const auto layerProps = scheduler::LayerProps{
                        .visible = layer->isVisible(),
                        .bounds = layer->getBounds(),
                        .transform = layer->getTransform(),
                        .setFrameRateVote = layer->getFrameRateForLayerTree(),
                        .frameRateSelectionPriority = layer->getFrameRateSelectionPriority(),
                };
                layer->recordLayerHistoryAnimationTx(layerProps);
            }
        }
    }

    transactionFlags |= clientStateFlags;
    // 将inputWindowCommands和SurfaceFlinger里面mInputWindowCommands merge
    transactionFlags |= addInputWindowCommands(inputWindowCommands);

    for (uint64_t uncacheBufferId : uncacheBufferIds) {
        mBufferIdsToUncache.push_back(uncacheBufferId);
    }

    // 如果是没有任何改变，空动画事务可以用于模拟背压，所以也可以强制执行
    if (transactionFlags == 0 && (flags & eAnimation)) {
        transactionFlags = eTransactionNeeded;
    }

    bool needsTraversal = false;
    if (transactionFlags) {
        // 清理标志位，设needsTraversal为true，表示要进行这次合成。
        if (transactionFlags & eTraversalNeeded) {
            transactionFlags = transactionFlags & (~eTraversalNeeded);
            needsTraversal = true;
        }
        if (transactionFlags) {
            setTransactionFlags(transactionFlags);
        }
    }

    return needsTraversal;
}

applyTransactionState 将 TranscationState 里面的所有变化信息都更新到对应变量里，然后根据是否有更新，返回对应 flag。

对于我们的 Demo，我们主要关心三类信息的处理，配置信息，buffe 信息，回调信息, Fence 锁，这些信息都在 ResolvedComposerState 中。这里信息都是通过 setClientStateLocked 函数来处理。这个函数巨长，我们就看我们关心的点：

uint32_t SurfaceFlinger::setClientStateLocked(const FrameTimelineInfo& frameTimelineInfo,
                                              ResolvedComposerState& composerState,
                                              int64_t desiredPresentTime, bool isAutoTimestamp,
                                              int64_t postTime, uint64_t transactionId) {
    layer_state_t& s = composerState.state;

    // ......

    if (layer == nullptr) {
        for (auto& [listener, callbackIds] : s.listeners) {
            mTransactionCallbackInvoker.addCallbackHandle(sp<CallbackHandle>::make(listener,
                                                                                   callbackIds,
                                                                                   s.surface),
                                                          std::vector<JankData>());
        }
        return 0;
    }
    MUTEX_ALIAS(mStateLock, layer->mFlinger->mStateLock);

    ui::LayerStack oldLayerStack = layer->getLayerStack(LayerVector::StateSet::Current);

    // Only set by BLAST adapter layers
    if (what & layer_state_t::eProducerDisconnect) {
        layer->onDisconnect();
    }

    if (what & layer_state_t::ePositionChanged) {
        if (layer->setPosition(s.x, s.y)) {
            flags |= eTraversalNeeded;
        }
    }

    // ......

    if (what & layer_state_t::eBufferChanged) {
        // 我们关心的信息都在 bufferData 里面，这里设置给了 layer
        if (layer->setBuffer(composerState.externalTexture, *s.bufferData, postTime,
                             desiredPresentTime, isAutoTimestamp, dequeueBufferTimestamp,
                             frameTimelineInfo)) {
            flags |= eTraversalNeeded;
        }
    } else if (frameTimelineInfo.vsyncId != FrameTimelineInfo::INVALID_VSYNC_ID) {
        layer->setFrameTimelineVsyncForBufferlessTransaction(frameTimelineInfo, postTime);
    }

    if ((what & layer_state_t::eBufferChanged) == 0) {
        layer->setDesiredPresentTime(desiredPresentTime, isAutoTimestamp);
    }

    // ......

    return flags;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

我们关心的信息都在 composerState 里面，这里调用了 setBuffer 将这些信息存储在 Layer 对象中。

看下 Layer 的 setBuffer 实现：

bool Layer::setBuffer(std::shared_ptr<renderengine::ExternalTexture>& buffer,
                      const BufferData& bufferData, nsecs_t postTime, nsecs_t desiredPresentTime,
                      bool isAutoTimestamp, std::optional<nsecs_t> dequeueTime,
                      const FrameTimelineInfo& info) {
    ATRACE_FORMAT("setBuffer %s - hasBuffer=%s", getDebugName(), (buffer ? "true" : "false"));

  

    // ......

    // releaseBuffer 回调
    mDrawingState.releaseBufferListener = bufferData.releaseBufferListener;
    // buffer
    mDrawingState.buffer = std::move(buffer);
    // app 绘制的 fence
    mDrawingState.acquireFence = bufferData.flags.test(BufferData::BufferDataChange::fenceChanged)
            ? bufferData.acquireFence
            : Fence::NO_FENCE;
    mDrawingState.acquireFenceTime = std::make_unique<FenceTime>(mDrawingState.acquireFence);
  
    // ......

    mDrawingState.releaseBufferEndpoint = bufferData.releaseBufferEndpoint;
    return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

可以看出，这些信息都保存在了 Layer 的 mDrawingState 成员中。

接下来，我们继续分析 commitTransactions 函数的实现

void SurfaceFlinger::commitTransactions() {
    // ......
    State drawingState(mDrawingState);
    Mutex::Autolock lock(mStateLock);
    commitTransactionsLocked(clearTransactionFlags(eTransactionMask));
}

1
2
3
4
5
6

加了锁以后调用 commitTransactionsLocked:

void SurfaceFlinger::commitTransactionsLocked(uint32_t transactionFlags) {
    // Commit display transactions.
    const bool displayTransactionNeeded = transactionFlags & eDisplayTransactionNeeded;
    mFrontEndDisplayInfosChanged = displayTransactionNeeded;
    if (displayTransactionNeeded && !mLayerLifecycleManagerEnabled) {
        // 应用 display 相关的配置，比如旋转，屏幕大小等。会更新相关的变量，比如 DisplayDeviceState 和 DisplayDevice
        processDisplayChangesLocked();
        mFrontEndDisplayInfos.clear();
        for (const auto& [_, display] : mDisplays) {
            mFrontEndDisplayInfos.try_emplace(display->getLayerStack(), display->getFrontEndInfo());
        }
    }
    mForceTransactionDisplayChange = displayTransactionNeeded;
    // 如果有子节点变化，设置 mVisibleRegionsDirtymUpdateInputInfo为true
    if (mSomeChildrenChanged) {
        mVisibleRegionsDirty = true;
        mSomeChildrenChanged = false;
        mUpdateInputInfo = true;
    }

    // 更新transform hint（旋转相关）
    if (transactionFlags & (eTransformHintUpdateNeeded | eDisplayTransactionNeeded)) {
        sp<const DisplayDevice> hintDisplay;
        ui::LayerStack layerStack;

        mCurrentState.traverse([&](Layer* layer) REQUIRES(mStateLock) {
            // 遍历所有layer，根据layer的LayerStack获取他对应的屏幕，根据屏幕的transform hint更新layer的transform hint
            // 前面提过transform hint是代表旋转的情况。
            if (const auto filter = layer->getOutputFilter(); layerStack != filter.layerStack) {
                layerStack = filter.layerStack;
                hintDisplay = nullptr;

                // Find the display that includes the layer.
                for (const auto& [token, display] : mDisplays) {
                    if (!display->getCompositionDisplay()->includesLayer(filter)) {
                        continue;
                    }

                    // Pick the primary display if another display mirrors the layer.
                    if (hintDisplay) {
                        hintDisplay = nullptr;
                        break;
                    }

                    hintDisplay = display;
                }
            }

            if (!hintDisplay) {

                ALOGV("Skipping reporting transform hint update for %s", layer->getDebugName());
                layer->skipReportingTransformHint();
            } else {
                layer->updateTransformHint(hintDisplay->getTransformHint());
            }
        });
    }
    // 如果添加了layer，设置 mVisibleRegionsDirty 和mUpdateInputInfo为true
    if (mLayersAdded) {
        mLayersAdded = false;
        // Layers have been added.
        mVisibleRegionsDirty = true;
        mUpdateInputInfo = true;
    }

    // 如果有layer被删除，需要更新display的state对应dirtyRegion变量，表示区域需要刷新。
    if (mLayersRemoved) {
        mLayersRemoved = false;
        mVisibleRegionsDirty = true;
        mUpdateInputInfo = true;
        mDrawingState.traverseInZOrder([&](Layer* layer) {
            if (mLayersPendingRemoval.indexOf(sp<Layer>::fromExisting(layer)) >= 0) {
                // this layer is not visible anymore
                Region visibleReg;
                visibleReg.set(layer->getScreenBounds());
                invalidateLayerStack(layer->getOutputFilter(), visibleReg);
            }
        });
    }

    if (transactionFlags & eInputInfoUpdateNeeded) {
        mUpdateInputInfo = true;
    }
  
    doCommitTransactions();
}

commitTransactionsLocked 先更新了屏幕相关的配置，然后遍历 layer，利用 layer 里面的 LayerStack 找到 layer 对应的屏，根据屏幕的旋转更新 layer 的旋转

如果有增加或者删除 layer，标记 mVisibleRegionsDirty 和 mUpdateInputInfo 为 true,遍历要删除的所有 layer，将他们的可见区域重叠，这些区域是需要刷新的。

最后调用 doCommitTransactions

void SurfaceFlinger::doCommitTransactions() {
    ATRACE_CALL();

    if (!mLayersPendingRemoval.isEmpty()) {
        // 处理需要删除的layer，释放buffer，如果是root layer，从mCurrentState.layersSortedByZ中移除
        for (const auto& l : mLayersPendingRemoval) {
            // 锁存并释放buffer
            if (l->isRemovedFromCurrentState()) {
                l->latchAndReleaseBuffer();
            }
            // 根节点会挂在mCurrentState.layersSortedByZ，如果要移除则需要从这个数组remove
            if (l->isAtRoot()) {
                l->setIsAtRoot(false);
                mCurrentState.layersSortedByZ.remove(l);
            }

            // 如果没有父节点，移除后我们就无法拿到这个layer了。将它存在mOffscreenLayers
            if (!l->getParent()) {
                mOffscreenLayers.emplace(l.get());
            }
        }
        mLayersPendingRemoval.clear();
    }
    // 将mCurrentState赋值给mDrawingState
    mDrawingState = mCurrentState;

    mCurrentState.colorMatrixChanged = false;

    // 递归调用所有layer commitChildList，里面主要是将 mDrawingChildren 和 mDrawingParent 更新成 mCurrentChildren，mCurrentParent
    if (mVisibleRegionsDirty) {
        for (const auto& rootLayer : mDrawingState.layersSortedByZ) {
            rootLayer->commitChildList();
        }
    }
    // 遍历所有上面加入mOffscreenLayers的layer，这些layer不在layer树上，所以上面递归遍历不到
    // 对每个layer调用doTransaction和commitChildList，doTransaction后面再介绍
    commitOffscreenLayers();
    if (mLayerMirrorRoots.size() > 0) {
        // 。。。同步更新mirrorlayer
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

doCommitTransactions 先处理需要删除的 layer，如果是 root layer，就将它从 layersSortedByZ 删除，没有父节点的就加到 mOffscreenLayers，防止后面需要遍历的时候我们拿不到他们了。

currentState/currentChildren/currentParent 都相当于中间变量，我们的改变都先配置在他们上，当要去使用它，让它生效时，就会赋值到 DrawingXXX 上。

commitChildList 会递归所有 child，然后将每个 layer 的将 mDrawingChildren 和 mDrawingParent 更新成 mCurrentChildren，mCurrentParent。最后同步更新 mirrorlayer 里面的属性

我们的示例代码并没有涉及到这部分内容，了解一下。

最后看 latchBuffers 的实现：

bool SurfaceFlinger::latchBuffers() {
    // ......
    mDrawingState.traverse([&](Layer* layer) {
        if (layer->clearTransactionFlags(eTransactionNeeded) || mForceTransactionDisplayChange) {
            // 调用 layer 的 doTransaction
            const uint32_t flags = layer->doTransaction(0);
            if (flags & Layer::eVisibleRegion) {
                mVisibleRegionsDirty = true;
            }
        }
        // 存储需要更新的 layer 到 mLayersWithQueuedFrames
        // 要不就是有变化的 layer，要不就是需要锁存并且释放 buffer 的 layer（mDrawingState.buffer为空且mBufferInfo.mBuffer不为空）
        if (layer->hasReadyFrame() || layer->willReleaseBufferOnLatch()) {
            frameQueued = true;
            mLayersWithQueuedFrames.emplace(sp<Layer>::fromExisting(layer));
        } else {
            layer->useEmptyDamage();
            if (!layer->hasBuffer()) {
                layer->updateLastLatchTime(latchTime);
            }
        }
    });

    mForceTransactionDisplayChange = false;

    // mOffscreenLayers里面存储到是被移除的layer，客户端还可以继续提交buffer，只是因为不在layer树上，不会显示在屏幕上，
    // 所以我们需要锁存并且释放 buffer  
    // latchAndReleaseBuffer 方法里面也调用了 latchBuffer，我们两个方法一起看了。
    for (Layer* offscreenLayer : mOffscreenLayers) {
        offscreenLayer->traverse(LayerVector::StateSet::Drawing,
                                        [&](Layer* l) { l->latchAndReleaseBuffer(); });
    }

    if (!mLayersWithQueuedFrames.empty()) {
        Mutex::Autolock lock(mStateLock);

        for (const auto& layer : mLayersWithQueuedFrames) {
            // 需要锁存并且释放 buffer 的 layer 存到 mLayersWithBuffersRemoved
            if (layer->willReleaseBufferOnLatch()) {
                mLayersWithBuffersRemoved.emplace(layer);
            }
            // latchBuffer，锁存 buffer，latchAndReleaseBuffer 里面也调用了该方法
            if (layer->latchBuffer(visibleRegions, latchTime)) {
                mLayersPendingRefresh.push_back(layer);
                newDataLatched = true;
            }
            layer->useSurfaceDamage();
        }
    }

    mVisibleRegionsDirty |= visibleRegions;

    if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) {
        scheduleCommit(FrameHint::kNone);
    }

    // 启动动画
    if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) {
        ALOGI("Enter boot animation");
        mBootStage = BootStage::BOOTANIMATION;
    }

    // 更新 mirror layer
    if (mLayerMirrorRoots.size() > 0) {
        mDrawingState.traverse([&](Layer* layer) { layer->updateCloneBufferInfo(); });
    }

    // 如果有需要更新的 frame 并且 layer 锁成功了
    return !mLayersWithQueuedFrames.empty() && newDataLatched;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

SurfaceFlinger::latchBuffers 主要有以下几个点需要关注：

此时 mDrawingState 已经是更新过的 mDrawState，遍历更新过的 layer，根据 TransactionFlag 有变化的layer，执行 doTransaction。
如果 layer 有变化，或者新的 buffer 被设置为空，需要释放旧的 buffer 的 layer，都添加到 mLayersWithQueuedFrames，然后遍历这个数组，调用里面每个 layer 的 latchBuffer。把需要更新的 Layer 存到 mLayersPendingRefresh，需要 release 的 Layer 存到 mLayersWithBuffersRemoved 中
遍历 mOffscreenLayers 调用每个 layer 的 latchAndReleaseBuffer，虽然这些 layer 已经不会在屏幕上显示了，但是 client 依旧可以提交 buffer，而且之前的 buffer 也需要 release

doTransaction 的实现如下：

uint32_t Layer::doTransaction(uint32_t flags) {
    // ......

    // 调用 updateGeometry 重新计算 Transform 信息（和buffer的大小缩放和平移关系）
    if (updateGeometry()) {
        flags |= Layer::eVisibleRegion;
    }

    if (s.sequence != mLastCommittedTxSequence) {
        mLastCommittedTxSequence = s.sequence;
        flags |= eVisibleRegion;
        this->contentDirty = true;

        mNeedsFiltering = getActiveTransform(s).needsBilinearFiltering();
    }

    if (!mPotentialCursor && (flags & Layer::eVisibleRegion)) {
        mFlinger->mUpdateInputInfo = true;
    }
    // 更新 mFrameTimeline，记录作用就不看了。
    commitTransaction(mDrawingState);

    return flags;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

调用 updateGeometry 重新计算 buffer 的大小缩放和平移关系（Transform），然后还调用了commitTransaction，记录 frame 时间信息。

Layer::latchBuffer 的实现如下：

bool Layer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime) {
    const bool bgColorOnly = mDrawingState.bgColorLayer != nullptr;
    return latchBufferImpl(recomputeVisibleRegions, latchTime, bgColorOnly);
}

1
2
3
4

进一步调用 latchBufferImpl：

bool Layer::latchBufferImpl(bool& recomputeVisibleRegions, nsecs_t latchTime, bool bgColorOnly) {
    // ......
    // 回调 client 侧的 ON_COMMIT 的 callback
    updateTexImage(latchTime, bgColorOnly);

    BufferInfo oldBufferInfo = mBufferInfo;
    const bool oldOpacity = isOpaque(mDrawingState);
    mPreviousFrameNumber = mCurrentFrameNumber;
    mCurrentFrameNumber = mDrawingState.frameNumber;
    // 构建 BufferInfo，将 mDrawingState 里 buffer 相关的信息存入
    gatherBufferInfo();

    if (mBufferInfo.mBuffer) {
        mPreviouslyPresentedLayerStacks.clear();
    }

    // 。。。对比新旧BufferInfo的一些参数变化，如果宽高等变化设置recomputeVisibleRegions为true，表示需要重新计算脏区域。

    return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

latchBufferImpl 中：

通过 updateTexImage 回调 client 侧 ON_COMMIT 的 callback。
通过 gatherBufferInfo 构建新的 BufferInfo

updateTexImage 的实现如下：

void Layer::updateTexImage(nsecs_t latchTime, bool bgColorOnly) {
    const State& s(getDrawingState());

    // ......

    // 回调 ON_COMMIT 的 callback
    std::deque<sp<CallbackHandle>> remainingHandles;
    mFlinger->getTransactionCallbackInvoker()
            .addOnCommitCallbackHandles(mDrawingState.callbackHandles, remainingHandles);
    mDrawingState.callbackHandles = remainingHandles;

    mDrawingStateModified = false;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

gatherBufferInfo 的实现如下：

void Layer::gatherBufferInfo() {

    // 处理上一个bufferInfo，mPreviousReleaseBufferEndpoint关联了client侧releaseBufferBuffer的回调。
    // 后续调用 mPreviousReleaseBufferEndpoint 回调就可以释放上一个 BufferInfo 的 Buffer 了。
    mPreviousReleaseCallbackId = {getCurrentBufferId(), mBufferInfo.mFrameNumber};
    mPreviousReleaseBufferEndpoint = mBufferInfo.mReleaseBufferEndpoint;
    if (!mDrawingState.buffer) {
        mBufferInfo = {};
        return;
    }

    if ((!mBufferInfo.mBuffer || !mDrawingState.buffer->hasSameBuffer(*mBufferInfo.mBuffer))) {
        decrementPendingBufferCount();
    }

    // 构建 BufferInfo，将 mDrawingState 内 Buffer 相关的信息放到 BufferInfo 内。
    mBufferInfo.mBuffer = mDrawingState.buffer;
    mBufferInfo.mReleaseBufferEndpoint = mDrawingState.releaseBufferEndpoint;
    mBufferInfo.mFence = mDrawingState.acquireFence;
    mBufferInfo.mFrameNumber = mDrawingState.frameNumber;
    mBufferInfo.mPixelFormat =
            !mBufferInfo.mBuffer ? PIXEL_FORMAT_NONE : mBufferInfo.mBuffer->getPixelFormat();
    mBufferInfo.mFrameLatencyNeeded = true;
    mBufferInfo.mDesiredPresentTime = mDrawingState.desiredPresentTime;
    mBufferInfo.mFenceTime = std::make_shared<FenceTime>(mDrawingState.acquireFence);
    mBufferInfo.mFence = mDrawingState.acquireFence;
    mBufferInfo.mTransform = mDrawingState.bufferTransform;
    auto lastDataspace = mBufferInfo.mDataspace;
    mBufferInfo.mDataspace = translateDataspace(mDrawingState.dataspace);
    if (mBufferInfo.mBuffer != nullptr) {
        auto& mapper = GraphicBufferMapper::get();
        ui::Dataspace dataspace = ui::Dataspace::UNKNOWN;
        status_t err = OK;
        {
            ATRACE_NAME("getDataspace");
            err = mapper.getDataspace(mBufferInfo.mBuffer->getBuffer()->handle, &dataspace);
        }
        if (err != OK || dataspace != mBufferInfo.mDataspace) {
            {
                ATRACE_NAME("setDataspace");
                err = mapper.setDataspace(mBufferInfo.mBuffer->getBuffer()->handle,
                                        static_cast<ui::Dataspace>(mBufferInfo.mDataspace));
            }
            static const int32_t kVendorVersion =
                    base::GetIntProperty("ro.vndk.version", __ANDROID_API_FUTURE__);
            if (const auto format =
                        static_cast<aidl::android::hardware::graphics::common::PixelFormat>(
                                mBufferInfo.mBuffer->getPixelFormat());
                err == OK && kVendorVersion < __ANDROID_API_U__ &&
                (format ==
                        aidl::android::hardware::graphics::common::PixelFormat::
                                IMPLEMENTATION_DEFINED ||
                format == aidl::android::hardware::graphics::common::PixelFormat::YCBCR_420_888 ||
                format == aidl::android::hardware::graphics::common::PixelFormat::YV12 ||
                format == aidl::android::hardware::graphics::common::PixelFormat::YCBCR_P010)) {
                mBufferInfo.mBuffer->remapBuffer();
            }
        }
    }
    if (lastDataspace != mBufferInfo.mDataspace) {
        mFlinger->mHdrLayerInfoChanged = true;
    }
    if (mBufferInfo.mDesiredHdrSdrRatio != mDrawingState.desiredHdrSdrRatio) {
        mBufferInfo.mDesiredHdrSdrRatio = mDrawingState.desiredHdrSdrRatio;
        mFlinger->mHdrLayerInfoChanged = true;
    }
    mBufferInfo.mCrop = computeBufferCrop(mDrawingState);
    mBufferInfo.mScaleMode = NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW;
    mBufferInfo.mSurfaceDamage = mDrawingState.surfaceDamageRegion;
    mBufferInfo.mHdrMetadata = mDrawingState.hdrMetadata;
    mBufferInfo.mApi = mDrawingState.api;
    mBufferInfo.mTransformToDisplayInverse = mDrawingState.transformToDisplayInverse;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

先将上一个 BufferInfo 的 mReleaseBufferEndpoint 记录到 mPreviousReleaseBufferEndpoint。接着构建新的 BufferInfo，将 mDrawingState 内 Buffer 相关的信息放到 BufferInfo 内。

小结一下：

回顾了 App 端生成关键数据的几个片段涉及的流程
commit 主要是进行数据的预处理，为后续的 composite 合成做准备。
最终，这些数据经过层层处理，其中几个关键的数据需要我们有一些印象：
- SurfaceFlinger 的 mDrawingState 成员有一个 LayerVector layersSortedByZ; 成员，该成员保存了所有的 Layer，这些 Layer 通过树关系链接在一起
- Layer 的 BufferInfo mBufferInfo; 成员中有 Buffer 以及 App 绘制阶段的 fence 等信息

# 5. composite 合成图层整体分析

composite 的实现如下：

// /frameworks/native/services/surfaceflinger/SurfaceFlinger.h

// mDisplays 是一个 map 的数据容器，在 SurfaceFlinger 启动时初始化
// DisplayDevice 代表了一个屏幕
// IBinder 是 DisplayDevice 的 token 索引
display::DisplayMap<wp<IBinder>, const sp<DisplayDevice>> mDisplays GUARDED_BY(mStateLock);

// /frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
void SurfaceFlinger::composite(TimePoint frameTime, VsyncId vsyncId)
        FTL_FAKE_GUARD(kMainThreadContext) {
  
    // 准备后续合成需要的参数，这些参数都保存在 refreshArgs
    compositionengine::CompositionRefreshArgs refreshArgs;

    // 这里前面的一大段逻辑都是构建 refreshArgs，填充里面的变量，我们只看几个比较关键的
    // refreshArgs.outputs是一个 Output 数组，
    // SurfaceFlinger 记录屏幕的类 DisplayDevice，而里面包含一个 Display 就是继承 Output 的，这个类是 SurfaceFlinger 和 HWC 交互屏幕信息的关键类。

    // FTL_FAKE_GUARD 就是加 mStateLock 锁，然后返回 mDisplays
    const auto& displays = FTL_FAKE_GUARD(mStateLock, mDisplays);

    // outputs 的数量与屏幕数量一致
    refreshArgs.outputs.reserve(displays.size());
  
    std::vector<DisplayId> displayIds;
  
    for (const auto& [_, display] : displays) { // 遍历每一个 DisplayDevice
        bool dropFrame = false;
        if (display->isVirtual()) { // 虚拟屏幕，不用管
            Fps refreshRate = display->getAdjustedRefreshRate();
            using fps_approx_ops::operator>;
            dropFrame = (refreshRate > 0_Hz) && !mScheduler->isVsyncInPhase(frameTime, refreshRate);
        }
        if (!dropFrame) {
            // 关注点 1  refreshArgs.outputs
            // getCompositionDisplay 返回 DispalyDevice 的 Display 成员，output 是 Display 的父类
            refreshArgs.outputs.push_back(display->getCompositionDisplay());
        }
        display->tracePowerMode();
        displayIds.push_back(display->getId());
    }

    mPowerAdvisor->setDisplays(displayIds);

    // 如果需要的话，更新layerMetadata。里面是一些layer给上层使用的信息，比如layer所属的uid，layer的task_id,layer是否是游戏模式等等。
    const bool updateTaskMetadata = mCompositionEngine->getFeatureFlags().test(
            compositionengine::Feature::kSnapshotLayerMetadata);
    if (updateTaskMetadata && (mVisibleRegionsDirty || mLayerMetadataSnapshotNeeded)) {
        updateLayerMetadataSnapshot();
        mLayerMetadataSnapshotNeeded = false;
    }

    // 这里通过 SurfaceFlinger 里面记录的信息（包括 SurfaceFlinger.mDrawingState 里面的信息），还有 layer 里面的信息来填充 CompositionRefreshArgs
    if (DOES_CONTAIN_BORDER) {
        refreshArgs.borderInfoList.clear();
        mDrawingState.traverse([&refreshArgs](Layer* layer) {
            if (layer->isBorderEnabled()) {
                compositionengine::BorderRenderInfo info;
                info.width = layer->getBorderWidth();
                info.color = layer->getBorderColor();
                layer->traverse(LayerVector::StateSet::Drawing, [&info](Layer* ilayer) {
                    info.layerIds.push_back(ilayer->getSequence());
                });
                refreshArgs.borderInfoList.emplace_back(std::move(info));
            }
        });
    }

    refreshArgs.bufferIdsToUncache = std::move(mBufferIdsToUncache);


    // 关注点2 refreshArgs.layersWithQueuedFrames
    // commit 时会将有 Buffer 有变化的 layer 都放在 mLayersWithQueuedFrames 里。这里放到 refreshArgs 参数内的并不是 layer，而是 layerFE
    // layerFE 中有 mSnapshot 变量，类型是 LayerFECompositionState，里面包含后续合成需要的信息。
    refreshArgs.layersWithQueuedFrames.reserve(mLayersWithQueuedFrames.size());
    for (auto layer : mLayersWithQueuedFrames) {
        if (auto layerFE = layer->getCompositionEngineLayerFE())
            refreshArgs.layersWithQueuedFrames.push_back(layerFE);
    }

    const auto presentTime = systemTime();
    // 关注点3，调用 moveSnapshotsToCompositionArgs 来更新所有的 layerFE 的 mSnapshot
    // 所有的 layerFE 会被存储在 refreshArgs.layers 中
    std::vector<std::pair<Layer*, LayerFE*>> layers =
            moveSnapshotsToCompositionArgs(refreshArgs, /*cursorOnly=*/false, vsyncId.value);

    // 关注点4，合成的方法,
    mCompositionEngine->present(refreshArgs);

   // ......
}

代码很繁琐，但整体流程还是很好把握：

数据准备阶段：准备后续合成需要的数据 compositionengine::CompositionRefreshArgs refreshArgs，这些数据很多，我们主要关注几个比较重要：
- 关注点 1 的 refreshArgs.outputs
- 关注点 2 的 refreshArgs.layersWithQueuedFrames
- 关注点 3，更新所有 LayerFE 的 mSnapshot，并将 LayerFE 对象保存在 refreshArgs.layers 中
合成实施阶段：关注点 4，mCompositionEngine->present(refreshArgs) 发起图层的合成

接下来我们详细分析以上主要流程。

# 6. 数据准备阶段

合成需要的数据都会保存在 compositionengine::CompositionRefreshArgs refreshArgs 中，接下来我们分析其中比较重要的几个成员。

# 6.1 refreshArgs.outputs 的赋值过程分析

# 6.2 refreshArgs.layersWithQueuedFrames 的赋值过程分析

    // 关注点2 refreshArgs.layersWithQueuedFrames
    // commit 时会将有 Buffer 有变化的 layer 都放在 mLayersWithQueuedFrames 里。这里放到 refreshArgs 参数内的并不是 layer，而是 layerFE
    // layerFE 中有 mSnapshot 变量，类型是 LayerFECompositionState，里面包含后续合成需要的信息。
    refreshArgs.layersWithQueuedFrames.reserve(mLayersWithQueuedFrames.size());
    for (auto layer : mLayersWithQueuedFrames) {
        if (auto layerFE = layer->getCompositionEngineLayerFE())
            refreshArgs.layersWithQueuedFrames.push_back(layerFE);
    }

1
2
3
4
5
6
7
8

commit 时会将有 Buffer 有变化的 layer 都放在 mLayersWithQueuedFrames 里，回顾一下代码：

bool SurfaceFlinger::latchBuffers() {
    // ......
    mDrawingState.traverse([&](Layer* layer) {
        if (layer->clearTransactionFlags(eTransactionNeeded) || mForceTransactionDisplayChange) {
            // 调用 layer 的 doTransaction
            const uint32_t flags = layer->doTransaction(0);
            if (flags & Layer::eVisibleRegion) {
                mVisibleRegionsDirty = true;
            }
        }
        // 存储需要更新的 layer 到 mLayersWithQueuedFrames
        // 要不就是有变化的 layer，要不就是需要锁存并且释放 buffer 的 layer（mDrawingState.buffer为空且mBufferInfo.mBuffer不为空）
        if (layer->hasReadyFrame() || layer->willReleaseBufferOnLatch()) {
            frameQueued = true;
            mLayersWithQueuedFrames.emplace(sp<Layer>::fromExisting(layer));
        } else {
            layer->useEmptyDamage();
            if (!layer->hasBuffer()) {
                layer->updateLastLatchTime(latchTime);
            }
        }
    });

    //......

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

这里会把 mLayersWithQueuedFrames 中 Layer 的 layerFE 成员保存到 refreshArgs.layersWithQueuedFrames 中去。

# 6.3 refreshArgs.layers 的赋值过程分析

    // 关注点3，调用 moveSnapshotsToCompositionArgs 来更新 layerFE 的 mSnapshot
    // 所有的 layerFE 会被存储在 refreshArgs.layers 中
    std::vector<std::pair<Layer*, LayerFE*>> layers =
            moveSnapshotsToCompositionArgs(refreshArgs, /*cursorOnly=*/false, vsyncId.value);

1
2
3
4

moveSnapshotsToCompositionArgs 函数更新 layerFE 内 mSnapshot，更新后会将所有的 layerFE 存储在 refreshArgs.layers 中。

LayerFE，这个是合成过程中使用的 layer，和 layer 的关系有点类似双缓冲区，合成的时候不使用 layer 自身，而使用其中的 LayerFE，里面也有一个Snapshot，记录合成时候需要的信息。

接下来，我们来看 moveSnapshotsToCompositionArgs 的实现：

std::vector<std::pair<Layer*, LayerFE*>> SurfaceFlinger::moveSnapshotsToCompositionArgs(
        compositionengine::CompositionRefreshArgs& refreshArgs, bool cursorOnly, int64_t vsyncId) {
  
    std::vector<std::pair<Layer*, LayerFE*>> layers;
    // 这里 mLegacyFrontEndEnabled 和 mLayerLifecycleManagerEnabled 只有一个为 true，是不同的策略
    // 我的手机上走的是 mLegacyFrontEndEnabled 为 true 的逻辑
    if (mLayerLifecycleManagerEnabled) {
        // ......
    }
  
    if (mLegacyFrontEndEnabled && !mLayerLifecycleManagerEnabled) { // 走这个 case
        // 定义 moveSnapshots 方法，后面对所有 layer 都要调用这个方法。
        auto moveSnapshots = [&layers, &refreshArgs, cursorOnly](Layer* layer) {
            if (const auto& layerFE = layer->getCompositionEngineLayerFE()) {
                if (cursorOnly &&
                    layer->getLayerSnapshot()->compositionType !=
                            aidl::android::hardware::graphics::composer3::Composition::CURSOR)
                    return;
                // 调用 layer 的 updateSnapshot 更新 snapshot，
                layer->updateSnapshot(refreshArgs.updatingGeometryThisFrame);
                // 将 layer 内的 snapshot 移到 layerFE 内
                layerFE->mSnapshot = layer->stealLayerSnapshot();
                // 将layerFE存储到refreshArgs内，作为后续合成的参数。
                refreshArgs.layers.push_back(layerFE);
                layers.emplace_back(layer, layerFE.get());
            }
        };

        // 如果经过前面 commit 的预处理，mVisibleRegionsDirty 为 false，说明没有新增 layer，就只需要重新处理上一次 layer
        if (cursorOnly || !mVisibleRegionsDirty) {
            for (sp<Layer> layer : mPreviouslyComposedLayers) {
                moveSnapshots(layer.get());
            }
        } else {
            // 否则就需要遍历mDrawingState所有layer，调用moveSnapshots，moveSnapshots是上面定义的这方法
            mPreviouslyComposedLayers.clear();
            mDrawingState.traverseInZOrder(
                    [&moveSnapshots](Layer* layer) { moveSnapshots(layer); });
            mPreviouslyComposedLayers.reserve(layers.size());
            for (auto [layer, _] : layers) {
                mPreviouslyComposedLayers.push_back(sp<Layer>::fromExisting(layer));
            }
        }
    }

    return layers;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

这里会把之前 commit 时候，Transaction 同步到 layer 的变换信息全部同步到 snapshot 上，snapshot 是一个 LayerSnapshot 结构体，继承自 LayerFECompositionState，里面有大量 layer 的合成时候需要使用的信息。

void Layer::updateSnapshot(bool updateGeometry) {
    if (!getCompositionEngineLayerFE()) {
        return;
    }
    // 获取 snapshot，这里 snapshot 是一个 LayerSnapshot，继承自 LayerFECompositionState
    // 这个结构里面有大量layer相关的数据
    // 我们前面在commit的流程中已经将Transaction内包含等变化信息同步到layer上了，这里就是通过layer内的变量更新snapshot
    auto* snapshot = editLayerSnapshot();
    if (updateGeometry) {
        prepareBasicGeometryCompositionState();
        prepareGeometryCompositionState();
        snapshot->roundedCorner = getRoundedCornerState();
        snapshot->stretchEffect = getStretchEffect();
        snapshot->transformedBounds = mScreenBounds;
        if (mEffectiveShadowRadius > 0.f) {
            snapshot->shadowSettings = mFlinger->mDrawingState.globalShadowSettings;
            snapshot->shadowSettings.boundaries = mBounds;

            const float casterAlpha = snapshot->alpha;
            const bool casterIsOpaque =
                    ((mBufferInfo.mBuffer != nullptr) && isOpaque(mDrawingState));
            snapshot->shadowSettings.casterIsTranslucent = !casterIsOpaque || (casterAlpha < 1.0f);
            snapshot->shadowSettings.ambientColor *= casterAlpha;
            snapshot->shadowSettings.spotColor *= casterAlpha;
        }
        snapshot->shadowSettings.length = mEffectiveShadowRadius;
    }
    snapshot->contentOpaque = isOpaque(mDrawingState);
    snapshot->layerOpaqueFlagSet =
            (mDrawingState.flags & layer_state_t::eLayerOpaque) == layer_state_t::eLayerOpaque;
    snapshot->isHdrY410 = isHdrY410();
    sp<Layer> p = mDrawingParent.promote();
    if (p != nullptr) {
        snapshot->parentTransform = p->getTransform();
    } else {
        snapshot->parentTransform.reset();
    }
    snapshot->bufferSize = getBufferSize(mDrawingState);
    // buffer 
    snapshot->externalTexture = mBufferInfo.mBuffer;
    snapshot->hasReadyFrame = hasReadyFrame();
    preparePerFrameCompositionState();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

小结一下：

refreshArgs.outputs 中准备好了 Display 相关信息
refreshArgs.layersWithQueuedFrames 中准备好了 LayerFE，这些 LayerFE 要么是要更新 buffer，要么是要 release buffer
refreshArgs.layers 中准备好了所有的 LayerFE，且 LayerFE 的 mSnapshot 成员已更新，里面保存了合成需要的内容。

数据流向 App -> Layer -> LayerFE -> LayerSnapshot

# 7. 合成实施阶段

前面都是准备工作，present 发起图层合成过程：


using LayerFESet = std::unordered_set<sp<LayerFE>, LayerFESpHash>;

void CompositionEngine::present(CompositionRefreshArgs& args) {

    // 调用 args.layers 所有 layerFE 的 onPreComposition，这个方法里只是更新了 layerFE 的 mCompositionResult.refreshStartTime，记录了一下合成开始的时间
    preComposition(args);
    {
        LayerFESet latchedLayers;
        // 关注点 1
        // 这里的 output 前面介绍过是 Display 对象
        for (const auto& output : args.outputs) {
            output->prepare(args, latchedLayers);
        }
    }

    // 关注点 2
    for (const auto& output : args.outputs) {
        // 对每一个屏幕调用 present
        output->present(args);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

关注点1，主要是构建 OutputLayer 以及 HwcLayer
关注点2，合成图层，包含了 device 合成和 client 合成

# 7.1 Output::prepare 最后的准备

关注点 1

void Output::prepare(const compositionengine::CompositionRefreshArgs& refreshArgs,
                    LayerFESet& geomSnapshots) {
    rebuildLayerStacks(refreshArgs, geomSnapshots);
    uncacheBuffers(refreshArgs.bufferIdsToUncache);
}

1
2
3
4
5

调用 rebuildLayerStacks，最后的数据准备:

void Output::rebuildLayerStacks(const compositionengine::CompositionRefreshArgs& refreshArgs,
                                LayerFESet& layerFESet) {

    auto& outputState = editState();

    if (!outputState.isEnabled || CC_LIKELY(!refreshArgs.updatingOutputGeometryThisFrame)) {
        return;
    }

    compositionengine::Output::CoverageState coverage{layerFESet};

    coverage.aboveCoveredLayersExcludingOverlays = refreshArgs.hasTrustedPresentationListener
            ? std::make_optional<Region>()
            : std::nullopt;

    // 构建 OutputLayer，同时会计算每个 layer 的脏区
    collectVisibleLayers(refreshArgs, coverage);
    // 把所有 layer 最终的区域信息合集（相当于这个屏幕的区域信息合集）存到 OutputState 内。
    const ui::Transform& tr = outputState.transform;
    Region undefinedRegion{outputState.displaySpace.getBoundsAsRect()};
    undefinedRegion.subtractSelf(tr.transform(coverage.aboveOpaqueLayers));

    outputState.undefinedRegion = undefinedRegion;
    outputState.dirtyRegion.orSelf(coverage.dirtyRegion);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

Output 代表了一个显示设备，OutputLayer 代表一个图层

这里会构建 OutputLayer，计算各个区域大小。

OutputLayer，这个是一个合成的中间产物，相比于LayerFE，他记录了更多在合成过程中计算出来的信息，比如一些区域信息，比如脏区等。

调用 collectVisibleLayers：

void Output::collectVisibleLayers(const compositionengine::CompositionRefreshArgs& refreshArgs,
                                compositionengine::Output::CoverageState& coverage) {
    for (auto layer : reversed(refreshArgs.layers)) {
        // 遍历所有 layerFE，调用 ensureOutputLayerIfVisible,构建 OutputLayer，这些 OutputLayer 会暂时存在 mPendingOutputLayersOrderedByZ 里
        ensureOutputLayerIfVisible(layer, coverage);
    }
    // 把 buffer 有变化的 layer 存到 mReleasedLayers
    setReleasedLayers(refreshArgs);
    // 将 mPendingOutputLayersOrderedByZ 到数据转移到 mCurrentOutputLayersOrderedByZ
    finalizePendingOutputLayers();
}

1
2
3
4
5
6
7
8
9
10
11

给每个 layer 构建 OutputLayer，并且计算每个 layer 脏区等区域信息，最后把所有 layer 区域信息合集存到 OutputLayerCompositionState 作为屏幕的区域信息合集，以便后面合成使用。

void Output::ensureOutputLayerIfVisible(sp<compositionengine::LayerFE>& layerFE,
                                        compositionengine::Output::CoverageState& coverage) {
    // latchedLayer 存储 layerFE
    if (!coverage.latchedLayers.count(layerFE)) {
        coverage.latchedLayers.insert(layerFE);
    }

    // layerStack 标志每个 layerFE 所在 output，如果 layerFE 不在当前Output（即当前屏幕），就直接返回
    if (!includesLayer(layerFE)) {
        return;
    }

    // Obtain a read-only pointer to the front-end layer state
    // 返回的 LayerSnapshot
    const auto* layerFEState = layerFE->getCompositionState();
    if (CC_UNLIKELY(!layerFEState)) {
        return;
    }

    // ......

    bool computeAboveCoveredExcludingOverlays = coverage.aboveCoveredLayersExcludingOverlays &&
            !layerFEState->outputFilter.toInternalDisplay;

    // 不透明区域
    Region opaqueRegion;
    // 可见区域
    Region visibleRegion;
    // 所有被覆盖的区域
    Region coveredRegion;
    // 透明区域
    Region transparentRegion;
    // 阴影区域
    Region shadowRegion;

    // 上面的覆盖区域，不包括显示器覆盖层
    std::optional<Region> coveredRegionExcludingDisplayOverlays = std::nullopt;
  
    // 下面的逻辑都是计算这几个区域的。
    const ui::Transform& tr = layerFEState->geomLayerTransform;
    // 将layer的边界通过Transform转换，作为初始化的值（就是整个layer显示的区域）
    const Rect visibleRect(tr.transform(layerFEState->geomLayerBounds));
    visibleRegion.set(visibleRect);
    // 如果有配置阴影，半透明可见区域需要减去阴影的区域
    if (layerFEState->shadowRadius > 0.0f) {
        const auto inset = static_cast<int32_t>(ceilf(layerFEState->shadowRadius) * -1.0f);
        Rect visibleRectWithShadows(visibleRect);
        visibleRectWithShadows.inset(inset, inset, inset, inset);
        visibleRegion.set(visibleRectWithShadows);
        shadowRegion = visibleRegion.subtract(visibleRect);
    }

    if (visibleRegion.isEmpty()) {
        return;
    }

    // 如果layer是透明的，计算全透明区域，如果计算逻辑过于复杂则不计算，因为这里本来计算出来也只是用于合成的优化
    if (!layerFEState->isOpaque) {
        // 判断Transform里面旋转的flag是否是ROT_INVALID，是的话计算太复杂.如果是其他的旋转90，180这种，可以比较容易计算。
        if (tr.preserveRects()) {
            // 透明区域和边界交集就是计算出来的透明区域
            const Region clippedTransparentRegionHint =
                    layerFEState->transparentRegionHint.intersect(
                            Rect(layerFEState->geomLayerBounds));

            if (clippedTransparentRegionHint.isEmpty()) {
                // 没有透明区域
                transparentRegion.clear();
            } else {
                // 还需要做transform才是最终结果。
                transparentRegion = tr.transform(clippedTransparentRegionHint);
            }
        } else {
            // 计算复杂，不计算透明区域
            transparentRegion.clear();
        }
    }

    const auto layerOrientation = tr.getOrientation();
    // 如果页面不透明，切旋转变换也是常规的变换，不透明区域就是visibleRect，否则我们也不计算不透明区域
    if (layerFEState->isOpaque && ((layerOrientation & ui::Transform::ROT_INVALID) == 0)) {
        opaqueRegion.set(visibleRect);
    }

    // aboveCoveredLayers是之前layer的合集，这里的visible还没有剪去，所以是这个layer全部的可见区域
    // 交上上层所有可见区域集合，就是被覆盖的集合。
    coveredRegion = coverage.aboveCoveredLayers.intersect(visibleRegion);

    // 更新aboveCoveredLayers，就是加上当前layer的可见区域，
    coverage.aboveCoveredLayers.orSelf(visibleRegion);

    if (CC_UNLIKELY(computeAboveCoveredExcludingOverlays)) {
        coveredRegionExcludingDisplayOverlays =
                coverage.aboveCoveredLayersExcludingOverlays->intersect(visibleRegion);
        coverage.aboveCoveredLayersExcludingOverlays->orSelf(visibleRegion);
    }

    // 可见区域要剪去上层的不透明区域（就是被上层遮挡）
    visibleRegion.subtractSelf(coverage.aboveOpaqueLayers);

    if (visibleRegion.isEmpty()) {
        return;
    }

    // 这里获取上一次的这个 layerFE 对应的 OutputLayer，获取上一次的可见区域，用于计算脏区
    auto prevOutputLayerIndex = findCurrentOutputLayerForLayer(layerFE);
    auto prevOutputLayer =
            prevOutputLayerIndex ? getOutputLayerOrderedByZByIndex(*prevOutputLayerIndex) : nullptr;

    const Region kEmptyRegion;
    const Region& oldVisibleRegion =
            prevOutputLayer ? prevOutputLayer->getState().visibleRegion : kEmptyRegion;
    const Region& oldCoveredRegion =
            prevOutputLayer ? prevOutputLayer->getState().coveredRegion : kEmptyRegion;

    // compute this layer's dirty region
    Region dirty;
    // 如果 buffer 内容有更新， 那这次的可见区域加上上一次的可见区域都是脏区
    if (layerFEState->contentDirty) {
        dirty = visibleRegion;
        dirty.orSelf(oldVisibleRegion);
    } else {
        // Exposed是暴露区域，可见区剪去被覆盖的区域就是暴露的区域
        // 脏区 = 这次的可见区域和上次被覆盖的区域交集（就是上次没有显示出来的，但是这次可能会被显示出来，是比较保守的估计）+ 这次暴露出来的-上次暴露出来的（因为内容没有变化，上次暴露出来的部分不需要再管了）
        const Region newExposed = visibleRegion - coveredRegion;
        const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
        dirty = (visibleRegion & oldCoveredRegion) | (newExposed - oldExposed);
    }
    // 脏区域再剪去上层不透明的区域（上层不透明看不见，所以也不需要重新渲染计算）
    dirty.subtractSelf(coverage.aboveOpaqueLayers);

    // dirtyRegion 是所有 layer  脏区域的合集
    coverage.dirtyRegion.orSelf(dirty);

    // 更新 aboveOpaqueLayers（之前所有layer的不透明区域）
    coverage.aboveOpaqueLayers.orSelf(opaqueRegion);

    Region visibleNonTransparentRegion = visibleRegion.subtract(transparentRegion);

    const auto& outputState = getState();
    Region drawRegion(outputState.transform.transform(visibleNonTransparentRegion));
    drawRegion.andSelf(outputState.displaySpace.getBoundsAsRect());
    if (drawRegion.isEmpty()) {
        return;
    }

    Region visibleNonShadowRegion = visibleRegion.subtract(shadowRegion);

    // 关注点 根据 layerFE 构建 OutputLayer
    auto result = ensureOutputLayer(prevOutputLayerIndex, layerFE);

    // 关注点 更新 OutputLayerCompositionState 内的变量
    auto& outputLayerState = result->editState();
    outputLayerState.visibleRegion = visibleRegion;
    outputLayerState.visibleNonTransparentRegion = visibleNonTransparentRegion;
    outputLayerState.coveredRegion = coveredRegion;
    outputLayerState.outputSpaceVisibleRegion = outputState.transform.transform(
            visibleNonShadowRegion.intersect(outputState.layerStackSpace.getContent()));
    outputLayerState.shadowRegion = shadowRegion;
    outputLayerState.outputSpaceBlockingRegionHint =
            layerFEState->compositionType == Composition::DISPLAY_DECORATION
            ? outputState.transform.transform(
                    transparentRegion.intersect(outputState.layerStackSpace.getContent()))
            : Region();
    if (CC_UNLIKELY(computeAboveCoveredExcludingOverlays)) {
        outputLayerState.coveredRegionExcludingDisplayOverlays =
                std::move(coveredRegionExcludingDisplayOverlays);
    }
}

这个方法用于计算 layer 的脏区，经过循环遍历，对每个 layer 都调用了这个方法后，就可以得到所有 layer 的脏区，保存在 coverage，同时附带的产物还有所有 layer 不透明区域，可见区域等。

同时构建 OutputLayer，将每个 layer 这些区域信息存入 OutputLayerState。

ensureOutputLayer 构建 OutputLayer 的过程：

OutputLayer* ensureOutputLayer(std::optional<size_t> prevIndex,
                            const sp<LayerFE>& layerFE) {
    auto outputLayer = (prevIndex && *prevIndex <= mCurrentOutputLayersOrderedByZ.size())
            ? std::move(mCurrentOutputLayersOrderedByZ[*prevIndex])
            : BaseOutput::createOutputLayer(layerFE);
    auto result = outputLayer.get();
    // 构造的 outputLayer 存放在 mPendingOutputLayersOrderedByZ
    mPendingOutputLayersOrderedByZ.emplace_back(std::move(outputLayer));
    return result;
}

1
2
3
4
5
6
7
8
9
10

BaseOutput 实际类型是 android::compositionengine::impl::Display。

接着调用 createOutputLayer：

// frameworks/native/services/surfaceflinger/CompositionEngine/src/Display.cpp
std::unique_ptr<compositionengine::OutputLayer> Display::createOutputLayer(
        const sp<compositionengine::LayerFE>& layerFE) const {
  
    // 关注点1 构造一个 OutputLayer
    // android::compositionengine::impl::createOutputLayer
    auto outputLayer = impl::createOutputLayer(*this, layerFE);

    if (const auto halDisplayId = HalDisplayId::tryCast(mId);
        outputLayer && !mIsDisconnected && halDisplayId) {

        auto& hwc = getCompositionEngine().getHwComposer();
        // 关注点2
        // 创建 hwclayer
        auto hwcLayer = hwc.createLayer(*halDisplayId);
        ALOGE_IF(!hwcLayer, "Failed to create a HWC layer for a HWC supported display %s",
                 getName().c_str());
        outputLayer->setHwcLayer(std::move(hwcLayer));
    }
    return outputLayer;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

关注点1，调用 android::compositionengine::impl::createOutputLayer 构建 OutputLayer 对象：

// frameworks/native/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp
std::unique_ptr<compositionengine::OutputLayer> Output::createOutputLayer(
    const sp<LayerFE>& layerFE) const {
    return impl::createOutputLayer(*this, layerFE);
}

std::unique_ptr<OutputLayer> createOutputLayer(const compositionengine::Output& output,
                                           const sp<compositionengine::LayerFE>& layerFE) {
    // 模板函数，构造一个 OutputLayer
    return createOutputLayerTemplated<OutputLayer>(output, layerFE);
}

1
2
3
4
5
6
7
8
9
10
11

template <typename BaseOutputLayer>
std::unique_ptr<BaseOutputLayer> createOutputLayerTemplated(const Output& output,
                                                            sp<LayerFE> layerFE) {
    class OutputLayer final : public BaseOutputLayer {
    public:
// Clang incorrectly complains that these are unused.
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-local-typedef"

        using OutputLayerCompositionState = std::remove_const_t<
                std::remove_reference_t<decltype(std::declval<BaseOutputLayer>().getState())>>;
        using Output = std::remove_const_t<
                std::remove_reference_t<decltype(std::declval<BaseOutputLayer>().getOutput())>>;
        using LayerFE =
                std::remove_reference_t<decltype(std::declval<BaseOutputLayer>().getLayerFE())>;

#pragma clang diagnostic pop

        OutputLayer(const Output& output, const sp<LayerFE>& layerFE)
              : mOutput(output), mLayerFE(layerFE) {}
        ~OutputLayer() override = default;

    private:
        // compositionengine::OutputLayer overrides
        const Output& getOutput() const override { return mOutput; }
        LayerFE& getLayerFE() const override { return *mLayerFE; }
        const OutputLayerCompositionState& getState() const override { return mState; }
        OutputLayerCompositionState& editState() override { return mState; }

        // compositionengine::impl::OutputLayer overrides
        void dumpState(std::string& out) const override { mState.dump(out); }

        const Output& mOutput;
        const sp<LayerFE> mLayerFE;
        OutputLayerCompositionState mState;
    };

    return std::make_unique<OutputLayer>(output, layerFE);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

这里构建了一个内部类 OutputLayer 的对象，其继承关系如下：

20240816142139

关注点2，创建 hwcLayer：

std::shared_ptr<HWC2::Layer> HWComposer::createLayer(HalDisplayId displayId) {
    RETURN_IF_INVALID_DISPLAY(displayId, nullptr);

    auto expected = mDisplayData[displayId].hwcDisplay->createLayer();
    if (!expected.has_value()) {
        auto error = std::move(expected).error();
        RETURN_IF_HWC_ERROR(error, displayId, nullptr);
    }
    return std::move(expected).value();
}

1
2
3
4
5
6
7
8
9
10

mDisplayData 以及 hwcDisplay 的初始化过程在第三节已经分析过了。

base::expected<std::shared_ptr<HWC2::Layer>, hal::Error> Display::createLayer() {
    HWLayerId layerId = 0;
    // 拿到 ID
    auto intError = mComposer.createLayer(mId, &layerId);
    auto error = static_cast<Error>(intError);
    if (error != Error::NONE) {
        return base::unexpected(error);
    }

    // 再构建一个 Layer 对象
    auto layer = std::make_shared<impl::Layer>(mComposer, mCapabilities, *this, layerId);
    // 保存到 mLayers 成员中
    mLayers.emplace(layerId, layer);
    return layer;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

最后调用到 AidlComposer::createLayer：

Error AidlComposer::createLayer(Display display, Layer* outLayer) {
    int64_t layer;
    // binder 远程调用
    const auto status = mAidlComposerClient->createLayer(translate<int64_t>(display),
                                                         kMaxLayerBufferCount, &layer);
    if (!status.isOk()) {
        ALOGE("createLayer failed %s", status.getDescription().c_str());
        return static_cast<Error>(status.getServiceSpecificError());
    }

    *outLayer = translate<Layer>(layer);
    return Error::NONE;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

binder 远程调用 composer hal，返回一个 layer 的 id，然后使用这个 id，构建一个 Layer 对象。

这个 id 在两侧起了索引的作用。

hwcLayer，这个是和 HWC HAL 通信使用的结构，代表 HWC 层的 Layer，只有需要通过 HWC 合成的 Layer 才会有这个。

android::HWC2::impl::Layer 的定义如下


class Layer : public HWC2::Layer {
public:
    Layer(android::Hwc2::Composer& composer,
          const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>&
                  capabilities,
          HWC2::Display& display, hal::HWLayerId layerId);
    ~Layer() override;

    void onOwningDisplayDestroyed();

    hal::HWLayerId getId() const override { return mId; }

    hal::Error setCursorPosition(int32_t x, int32_t y) override;
    hal::Error setBuffer(uint32_t slot, const android::sp<android::GraphicBuffer>& buffer,
                         const android::sp<android::Fence>& acquireFence) override;
    hal::Error setBufferSlotsToClear(const std::vector<uint32_t>& slotsToClear,
                                     uint32_t activeBufferSlot) override;
    hal::Error setSurfaceDamage(const android::Region& damage) override;

    hal::Error setBlendMode(hal::BlendMode mode) override;
    hal::Error setColor(aidl::android::hardware::graphics::composer3::Color color) override;
    hal::Error setCompositionType(
            aidl::android::hardware::graphics::composer3::Composition type) override;
    hal::Error setDataspace(hal::Dataspace dataspace) override;
    hal::Error setPerFrameMetadata(const int32_t supportedPerFrameMetadata,
                                   const android::HdrMetadata& metadata) override;
    hal::Error setDisplayFrame(const android::Rect& frame) override;
    hal::Error setPlaneAlpha(float alpha) override;
    hal::Error setSidebandStream(const native_handle_t* stream) override;
    hal::Error setSourceCrop(const android::FloatRect& crop) override;
    hal::Error setTransform(hal::Transform transform) override;
    hal::Error setVisibleRegion(const android::Region& region) override;
    hal::Error setZOrder(uint32_t z) override;

    // Composer HAL 2.3
    hal::Error setColorTransform(const android::mat4& matrix) override;

    // Composer HAL 2.4
    hal::Error setLayerGenericMetadata(const std::string& name, bool mandatory,
                                       const std::vector<uint8_t>& value) override;

    // AIDL HAL
    hal::Error setBrightness(float brightness) override;
    hal::Error setBlockingRegion(const android::Region& region) override;

private:
    // These are references to data owned by HWComposer, which will outlive
    // this HWC2::Layer, so these references are guaranteed to be valid for
    // the lifetime of this object.
    android::Hwc2::Composer& mComposer;
    const std::unordered_set<aidl::android::hardware::graphics::composer3::Capability>&
            mCapabilities;

    HWC2::Display* mDisplay;
    hal::HWLayerId mId;

    // Cached HWC2 data, to ensure the same commands aren't sent to the HWC
    // multiple times.
    android::Region mVisibleRegion = android::Region::INVALID_REGION;
    android::Region mDamageRegion = android::Region::INVALID_REGION;
    android::Region mBlockingRegion = android::Region::INVALID_REGION;
    hal::Dataspace mDataSpace = hal::Dataspace::UNKNOWN;
    android::HdrMetadata mHdrMetadata;
    android::mat4 mColorMatrix;
    uint32_t mBufferSlot;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

impl::Layer 的构造函数如下：

// /frameworks/native/services/surfaceflinger/DisplayHardware/HWC2.cpp
Layer::Layer(android::Hwc2::Composer& composer,
             const std::unordered_set<AidlCapability>& capabilities, HWC2::Display& display,
             HWLayerId layerId)
      : mComposer(composer),
        mCapabilities(capabilities),
        mDisplay(&display),
        mId(layerId),
        mColorMatrix(android::mat4()) {
    ALOGV("Created layer %" PRIu64 " on display %" PRIu64, layerId, display.getId());
}

1
2
3
4
5
6
7
8
9
10
11

hwcLayer 构造完成后还有调用 setHwcLayer 方法：

void OutputLayer::setHwcLayer(std::shared_ptr<HWC2::Layer> hwcLayer) {
    auto& state = editState();
    if (hwcLayer) {
        state.hwc.emplace(std::move(hwcLayer));
    } else {
        state.hwc.reset();
    }
}

1
2
3
4
5
6
7
8

这里会把 hwcLayer 保存到 OutputLayer 的 OutputLayerCompositionState 成员的 hwc 成员的 hwcLayer 成员中，方便后续的合成操作

OutputLayer 创建完成后，接着调用 setReleasedLayers，把 buffer 有变化的 layer 存到 mReleasedLayers

void Display::setReleasedLayers(const compositionengine::CompositionRefreshArgs& refreshArgs) {
  
    Output::setReleasedLayers(refreshArgs);

    if (mIsDisconnected || GpuVirtualDisplayId::tryCast(mId) ||
        refreshArgs.layersWithQueuedFrames.empty()) {
        return;
    }

    // For layers that are being removed from a HWC display, and that have
    // queued frames, add them to a a list of released layers so we can properly
    // set a fence.
    compositionengine::Output::ReleasedLayers releasedLayers;

    // Any non-null entries in the current list of layers are layers that are no
    // longer going to be visible
    for (auto* outputLayer : getOutputLayersOrderedByZ()) {
        if (!outputLayer) {
            continue;
        }

        compositionengine::LayerFE* layerFE = &outputLayer->getLayerFE();
        const bool hasQueuedFrames =
                std::any_of(refreshArgs.layersWithQueuedFrames.cbegin(),
                            refreshArgs.layersWithQueuedFrames.cend(),
                            [layerFE](sp<compositionengine::LayerFE> layerWithQueuedFrames) {
                                return layerFE == layerWithQueuedFrames.get();
                            });

        if (hasQueuedFrames) {
            releasedLayers.emplace_back(wp<LayerFE>::fromExisting(layerFE));
        }
    }

    setReleasedLayers(std::move(releasedLayers));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

以上是最后的准备阶段。

# 7.2 Output::present 开始合成

前面可以说都是准备，接下来的 present 函数才是合成的重头戏：

void Output::present(const compositionengine::CompositionRefreshArgs& refreshArgs) {
    // 根据 refresh 里面的参数更新颜色空间等（像素点表示颜色的编码方式），存储在 OutputState
    updateColorProfile(refreshArgs);
    // 关注点1 调用所有 OutputLayer 的 updateCompositionState
    updateCompositionState(refreshArgs);
    planComposition();
    // 关注点2 将一部分合成状态写到 hwc，这里通过 HWCLayer，将状态同步到HWC侧，也是通过aidl的binder
    writeCompositionState(refreshArgs);
    // 更新颜色转换矩阵，类似于layer的Transform，只是这里是针对于颜色的。同时会更新state里面的脏区
    setColorTransform(refreshArgs);

    // 这里会调用RenderSurface的beginFrame，后会调用DisplaySurface的beginFrame，如果是虚拟屏则会有一些刷新hwc的buffer相关的处理，如果不是虚拟盘什么也没做
    beginFrame();

    GpuCompositionResult result;
    // 判断是否同步进行
    const bool predictCompositionStrategy = canPredictCompositionStrategy(refreshArgs);
    // 无论是否同步最后都会走到 finishPrepareFrame，然后也是调用 renderSurface 的 prepareFrame，再调用 DisplaySurface 的 prepareFrame。如果是主屏这里也什么都没做
    // 如果是 prepareFrameAsync，会调用 dequeueRenderBuffer 和 composeSurfaces 进行合成操作，如果是 prepareFrame，合成操作在 finishFrame
    // 合成操作就在 finishFrame 里再介绍
   
    if (predictCompositionStrategy) {
        result = prepareFrameAsync();
    } else {
         // 关注点3 看 else 的逻辑
        prepareFrame();
    }

    devOptRepaintFlash(refreshArgs);
    // 关注点4
    // 如果之前走的是 prepareFrame，会在这里进行合成操作，调用 dequeueRenderBuffer 和 composeSurfaces
    finishFrame(std::move(result));
    // 关注点5
    // 主要调用了 presentAndGetFrameFences 将剩余的 layer 提交给 HWC，让 HWC 进行硬件合成。除此之外会处理一些 buffer 的释放相关工作。
    postFramebuffer();
    renderCachedSets(refreshArgs);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

关注点1，调用所有 OutputLayer 的 updateCompositionState，更新 OutputLayer 的 state 的部分成员
关注点2，将一部分合成状态写到 writer 中
关注点3，prepareFrame 完成部分 OutputLayer device 合成的同时从 HWC HAL 中获取到 OutputLayer 们的合成方式
关注点4，finishFrame，如果需要，完成 OutputLayer 的 client 合成
关注点5，postFramebuffer 完成后续所有 OutputLayer 的 device 合成

# 7.2.1 AidlComposer 的设计

预备知识点：所有的图层合成操作都需要通过 AidlComposer 这个中介与 hwc hal 通信完成，所有我们需要了解 AidlComposer 的设计与实现。

AidlComposer 是 hwc hal 的客户端包装类，方便客户端使用 binder 服务。系统源码很多这种实现。

AidlComposer 的定义如下：

// /frameworks/native/services/surfaceflinger/DisplayHardware/AidlComposerHal.h
// Composer is a wrapper to IComposer, a proxy to server-side composer.
class AidlComposer final : public Hwc2::Composer {
public:
    static bool isDeclared(const std::string& serviceName);

    explicit AidlComposer(const std::string& serviceName);
    ~AidlComposer() override;

    bool isSupported(OptionalFeature) const;

    std::vector<aidl::android::hardware::graphics::composer3::Capability> getCapabilities()
            override;
    std::string dumpDebugInfo() override;

    void registerCallback(HWC2::ComposerCallback& callback) override;

    // .......
    // 定义了一堆的函数，省略了，遇到我们直接看实现

    // 64KiB minus a small space for metadata such as read/write pointers
    static constexpr size_t kWriterInitialSize = 64 * 1024 / sizeof(uint32_t) - 16;
    // Max number of buffers that may be cached for a given layer
    // We obtain this number by:
    // 1. Tightly coupling this cache to the max size of BufferQueue
    // 2. Adding an additional slot for the layer caching feature in SurfaceFlinger (see: Planner.h)
    static const constexpr uint32_t kMaxLayerBufferCount = BufferQueue::NUM_BUFFER_SLOTS + 1;

    // Without DisplayCapability::MULTI_THREADED_PRESENT, we use a single reader
    // for all displays. With the capability, we use a separate reader for each
    // display.
    bool mSingleReader = true;
    // Invalid displayId used as a key to mReaders when mSingleReader is true.
    static constexpr int64_t kSingleReaderKey = 0;

    // TODO (b/256881188): Use display::PhysicalDisplayMap instead of hard-coded `3`
    ftl::SmallMap<Display, ComposerClientWriter, 3> mWriters GUARDED_BY(mMutex);
    ftl::SmallMap<Display, ComposerClientReader, 3> mReaders GUARDED_BY(mMutex);
    // Protect access to mWriters and mReaders with a shared_mutex. Adding and
    // removing a display require exclusive access, since the iterator or the
    // writer/reader may be invalidated. Other calls need shared access while
    // using the writer/reader, so they can use their display's writer/reader
    // without it being deleted or the iterator being invalidated.
    // TODO (b/257958323): Use std::shared_mutex and RAII once they support
    // threading annotations.
    ftl::SharedMutex mMutex;

    // Whether or not explicitly clearing buffer slots is supported.
    bool mSupportsBufferSlotsToClear;
    // Buffer slots for layers are cleared by setting the slot buffer to this buffer.
    sp<GraphicBuffer> mClearSlotBuffer;

    // Aidl interface
    using AidlIComposer = aidl::android::hardware::graphics::composer3::IComposer;
    using AidlIComposerClient = aidl::android::hardware::graphics::composer3::IComposerClient;
    // binder 客户端类
    std::shared_ptr<AidlIComposer> mAidlComposer;
    std::shared_ptr<AidlIComposerClient> mAidlComposerClient;
    std::shared_ptr<AidlIComposerCallbackWrapper> mAidlComposerCallback;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

两个重要的成员 mWriters mReaders，mWriters 用于暂存数据，远程调用时，使用这些数据，mReaders 用于读取远程调用后返回的数据。

mAidlComposer 和 mAidlComposerClient 是 binder 客户端对象，用于发起远程调用。

ComposerClientWriter 实现如下：

class ComposerClientWriter final {
  public:
    static constexpr std::optional<ClockMonotonicTimestamp> kNoTimestamp = std::nullopt;

    explicit ComposerClientWriter(int64_t display) : mDisplay(display) { reset(); }

    ~ComposerClientWriter() { reset(); }

    ComposerClientWriter(ComposerClientWriter&&) = default;

    ComposerClientWriter(const ComposerClientWriter&) = delete;
    ComposerClientWriter& operator=(const ComposerClientWriter&) = delete;

    void setColorTransform(int64_t display, const float* matrix) {
        std::vector<float> matVec;
        matVec.reserve(16);
        matVec.assign(matrix, matrix + 16);
        getDisplayCommand(display).colorTransformMatrix.emplace(std::move(matVec));
    }

    void setDisplayBrightness(int64_t display, float brightness, float brightnessNits) {
        getDisplayCommand(display).brightness.emplace(
                DisplayBrightness{.brightness = brightness, .brightnessNits = brightnessNits});
    }

    void setClientTarget(int64_t display, uint32_t slot, const native_handle_t* target,
                         int acquireFence, Dataspace dataspace, const std::vector<Rect>& damage) {
        ClientTarget clientTargetCommand;
        clientTargetCommand.buffer = getBufferCommand(slot, target, acquireFence);
        clientTargetCommand.dataspace = dataspace;
        clientTargetCommand.damage.assign(damage.begin(), damage.end());
        getDisplayCommand(display).clientTarget.emplace(std::move(clientTargetCommand));
    }

    void setOutputBuffer(int64_t display, uint32_t slot, const native_handle_t* buffer,
                         int releaseFence) {
        getDisplayCommand(display).virtualDisplayOutputBuffer.emplace(
                getBufferCommand(slot, buffer, releaseFence));
    }

    void validateDisplay(int64_t display,
                         std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
        auto& command = getDisplayCommand(display);
        command.expectedPresentTime = expectedPresentTime;
        command.validateDisplay = true;
    }

    // 关注点
    void presentOrvalidateDisplay(int64_t display,
                                  std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
        auto& command = getDisplayCommand(display);
        command.expectedPresentTime = expectedPresentTime;
        command.presentOrValidateDisplay = true;
    }

    void acceptDisplayChanges(int64_t display) {
        getDisplayCommand(display).acceptDisplayChanges = true;
    }

    void presentDisplay(int64_t display) { getDisplayCommand(display).presentDisplay = true; }

    void setLayerCursorPosition(int64_t display, int64_t layer, int32_t x, int32_t y) {
        common::Point cursorPosition;
        cursorPosition.x = x;
        cursorPosition.y = y;
        getLayerCommand(display, layer).cursorPosition.emplace(std::move(cursorPosition));
    }

    void setLayerBuffer(int64_t display, int64_t layer, uint32_t slot,
                        const native_handle_t* buffer, int acquireFence) {
        getLayerCommand(display, layer).buffer = getBufferCommand(slot, buffer, acquireFence);
    }

    void setLayerBufferWithNewCommand(int64_t display, int64_t layer, uint32_t slot,
                                      const native_handle_t* buffer, int acquireFence) {
        flushLayerCommand();
        getLayerCommand(display, layer).buffer = getBufferCommand(slot, buffer, acquireFence);
        flushLayerCommand();
    }

    void setLayerBufferSlotsToClear(int64_t display, int64_t layer,
                                    const std::vector<uint32_t>& slotsToClear) {
        getLayerCommand(display, layer)
                .bufferSlotsToClear.emplace(slotsToClear.begin(), slotsToClear.end());
    }

    void setLayerSurfaceDamage(int64_t display, int64_t layer, const std::vector<Rect>& damage) {
        getLayerCommand(display, layer).damage.emplace(damage.begin(), damage.end());
    }

    void setLayerBlendMode(int64_t display, int64_t layer, BlendMode mode) {
        ParcelableBlendMode parcelableBlendMode;
        parcelableBlendMode.blendMode = mode;
        getLayerCommand(display, layer).blendMode.emplace(std::move(parcelableBlendMode));
    }

    void setLayerColor(int64_t display, int64_t layer, Color color) {
        getLayerCommand(display, layer).color.emplace(std::move(color));
    }

    void setLayerCompositionType(int64_t display, int64_t layer, Composition type) {
        ParcelableComposition compositionPayload;
        compositionPayload.composition = type;
        getLayerCommand(display, layer).composition.emplace(std::move(compositionPayload));
    }

    void setLayerDataspace(int64_t display, int64_t layer, Dataspace dataspace) {
        ParcelableDataspace dataspacePayload;
        dataspacePayload.dataspace = dataspace;
        getLayerCommand(display, layer).dataspace.emplace(std::move(dataspacePayload));
    }

    void setLayerDisplayFrame(int64_t display, int64_t layer, const Rect& frame) {
        getLayerCommand(display, layer).displayFrame.emplace(frame);
    }

    void setLayerPlaneAlpha(int64_t display, int64_t layer, float alpha) {
        PlaneAlpha planeAlpha;
        planeAlpha.alpha = alpha;
        getLayerCommand(display, layer).planeAlpha.emplace(std::move(planeAlpha));
    }

    void setLayerSidebandStream(int64_t display, int64_t layer, const native_handle_t* stream) {
        NativeHandle handle;
        if (stream) handle = ::android::dupToAidl(stream);
        getLayerCommand(display, layer).sidebandStream.emplace(std::move(handle));
    }

    void setLayerSourceCrop(int64_t display, int64_t layer, const FRect& crop) {
        getLayerCommand(display, layer).sourceCrop.emplace(crop);
    }

    void setLayerTransform(int64_t display, int64_t layer, Transform transform) {
        ParcelableTransform transformPayload;
        transformPayload.transform = transform;
        getLayerCommand(display, layer).transform.emplace(std::move(transformPayload));
    }

    void setLayerVisibleRegion(int64_t display, int64_t layer, const std::vector<Rect>& visible) {
        getLayerCommand(display, layer).visibleRegion.emplace(visible.begin(), visible.end());
    }

    void setLayerZOrder(int64_t display, int64_t layer, uint32_t z) {
        ZOrder zorder;
        zorder.z = static_cast<int32_t>(z);
        getLayerCommand(display, layer).z.emplace(std::move(zorder));
    }

    void setLayerPerFrameMetadata(int64_t display, int64_t layer,
                                  const std::vector<PerFrameMetadata>& metadataVec) {
        getLayerCommand(display, layer)
                .perFrameMetadata.emplace(metadataVec.begin(), metadataVec.end());
    }

    void setLayerColorTransform(int64_t display, int64_t layer, const float* matrix) {
        getLayerCommand(display, layer).colorTransform.emplace(matrix, matrix + 16);
    }

    void setLayerPerFrameMetadataBlobs(int64_t display, int64_t layer,
                                       const std::vector<PerFrameMetadataBlob>& metadata) {
        getLayerCommand(display, layer)
                .perFrameMetadataBlob.emplace(metadata.begin(), metadata.end());
    }

    void setLayerBrightness(int64_t display, int64_t layer, float brightness) {
        getLayerCommand(display, layer)
                .brightness.emplace(LayerBrightness{.brightness = brightness});
    }

    void setLayerBlockingRegion(int64_t display, int64_t layer, const std::vector<Rect>& blocking) {
        getLayerCommand(display, layer).blockingRegion.emplace(blocking.begin(), blocking.end());
    }

    std::vector<DisplayCommand> takePendingCommands() {
        flushLayerCommand();
        flushDisplayCommand();
        std::vector<DisplayCommand> moved = std::move(mCommands);
        mCommands.clear();
        return moved;
    }

  private:
    std::optional<DisplayCommand> mDisplayCommand;
    std::optional<LayerCommand> mLayerCommand;
    std::vector<DisplayCommand> mCommands;
    const int64_t mDisplay;

    Buffer getBufferCommand(uint32_t slot, const native_handle_t* bufferHandle, int fence) {
        Buffer bufferCommand;
        bufferCommand.slot = static_cast<int32_t>(slot);
        if (bufferHandle) bufferCommand.handle.emplace(::android::dupToAidl(bufferHandle));
        if (fence > 0) bufferCommand.fence = ::ndk::ScopedFileDescriptor(fence);
        return bufferCommand;
    }

    void flushLayerCommand() {
        if (mLayerCommand.has_value()) {
            mDisplayCommand->layers.emplace_back(std::move(*mLayerCommand));
            mLayerCommand.reset();
        }
    }

    void flushDisplayCommand() {
        if (mDisplayCommand.has_value()) {
            mCommands.emplace_back(std::move(*mDisplayCommand));
            mDisplayCommand.reset();
        }
    }

    DisplayCommand& getDisplayCommand(int64_t display) {
        if (!mDisplayCommand.has_value() || mDisplayCommand->display != display) {
            LOG_ALWAYS_FATAL_IF(display != mDisplay);
            flushLayerCommand();
            flushDisplayCommand();
            mDisplayCommand.emplace();
            mDisplayCommand->display = display;
        }
        return *mDisplayCommand;
    }

    LayerCommand& getLayerCommand(int64_t display, int64_t layer) {
        getDisplayCommand(display);
        if (!mLayerCommand.has_value() || mLayerCommand->layer != layer) {
            flushLayerCommand();
            mLayerCommand.emplace();
            mLayerCommand->layer = layer;
        }
        return *mLayerCommand;
    }

    void reset() {
        mDisplayCommand.reset();
        mLayerCommand.reset();
        mCommands.clear();
    }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236

方法一大堆，实际关注三个参数：

    std::optional<DisplayCommand> mDisplayCommand;
    std::optional<LayerCommand> mLayerCommand;
    std::vector<DisplayCommand> mCommands;

1
2
3

其中 LayerCommand 的实现如下：

class LayerCommand {
public:
  typedef std::false_type fixed_size;
  static const char* descriptor;

  int64_t layer = 0L;
  // 数据部分
  std::optional<::aidl::android::hardware::graphics::common::Point> cursorPosition;
  std::optional<::aidl::android::hardware::graphics::composer3::Buffer> buffer;
  std::optional<std::vector<std::optional<::aidl::android::hardware::graphics::common::Rect>>> damage;
  std::optional<::aidl::android::hardware::graphics::composer3::ParcelableBlendMode> blendMode;
  std::optional<::aidl::android::hardware::graphics::composer3::Color> color;
  std::optional<::aidl::android::hardware::graphics::composer3::ParcelableComposition> composition;
  std::optional<::aidl::android::hardware::graphics::composer3::ParcelableDataspace> dataspace;
  std::optional<::aidl::android::hardware::graphics::common::Rect> displayFrame;
  std::optional<::aidl::android::hardware::graphics::composer3::PlaneAlpha> planeAlpha;
  std::optional<::aidl::android::hardware::common::NativeHandle> sidebandStream;
  std::optional<::aidl::android::hardware::graphics::common::FRect> sourceCrop;
  std::optional<::aidl::android::hardware::graphics::composer3::ParcelableTransform> transform;
  std::optional<std::vector<std::optional<::aidl::android::hardware::graphics::common::Rect>>> visibleRegion;
  std::optional<::aidl::android::hardware::graphics::composer3::ZOrder> z;
  std::optional<std::vector<float>> colorTransform;
  std::optional<::aidl::android::hardware::graphics::composer3::LayerBrightness> brightness;
  std::optional<std::vector<std::optional<::aidl::android::hardware::graphics::composer3::PerFrameMetadata>>> perFrameMetadata;
  std::optional<std::vector<std::optional<::aidl::android::hardware::graphics::composer3::PerFrameMetadataBlob>>> perFrameMetadataBlob;
  std::optional<std::vector<std::optional<::aidl::android::hardware::graphics::common::Rect>>> blockingRegion;
  std::optional<std::vector<int32_t>> bufferSlotsToClear;

  binder_status_t readFromParcel(const AParcel* parcel);
  binder_status_t writeToParcel(AParcel* parcel) const;

  inline bool operator!=(const LayerCommand& rhs) const {
    return std::tie(layer, cursorPosition, buffer, damage, blendMode, color, composition, dataspace, displayFrame, planeAlpha, sidebandStream, sourceCrop, transform, visibleRegion, z, colorTransform, brightness, perFrameMetadata, perFrameMetadataBlob, blockingRegion, bufferSlotsToClear) != std::tie(rhs.layer, rhs.cursorPosition, rhs.buffer, rhs.damage, rhs.blendMode, rhs.color, rhs.composition, rhs.dataspace, rhs.displayFrame, rhs.planeAlpha, rhs.sidebandStream, rhs.sourceCrop, rhs.transform, rhs.visibleRegion, rhs.z, rhs.colorTransform, rhs.brightness, rhs.perFrameMetadata, rhs.perFrameMetadataBlob, rhs.blockingRegion, rhs.bufferSlotsToClear);
  }
  inline bool operator<(const LayerCommand& rhs) const {
    return std::tie(layer, cursorPosition, buffer, damage, blendMode, color, composition, dataspace, displayFrame, planeAlpha, sidebandStream, sourceCrop, transform, visibleRegion, z, colorTransform, brightness, perFrameMetadata, perFrameMetadataBlob, blockingRegion, bufferSlotsToClear) < std::tie(rhs.layer, rhs.cursorPosition, rhs.buffer, rhs.damage, rhs.blendMode, rhs.color, rhs.composition, rhs.dataspace, rhs.displayFrame, rhs.planeAlpha, rhs.sidebandStream, rhs.sourceCrop, rhs.transform, rhs.visibleRegion, rhs.z, rhs.colorTransform, rhs.brightness, rhs.perFrameMetadata, rhs.perFrameMetadataBlob, rhs.blockingRegion, rhs.bufferSlotsToClear);
  }
  inline bool operator<=(const LayerCommand& rhs) const {
    return std::tie(layer, cursorPosition, buffer, damage, blendMode, color, composition, dataspace, displayFrame, planeAlpha, sidebandStream, sourceCrop, transform, visibleRegion, z, colorTransform, brightness, perFrameMetadata, perFrameMetadataBlob, blockingRegion, bufferSlotsToClear) <= std::tie(rhs.layer, rhs.cursorPosition, rhs.buffer, rhs.damage, rhs.blendMode, rhs.color, rhs.composition, rhs.dataspace, rhs.displayFrame, rhs.planeAlpha, rhs.sidebandStream, rhs.sourceCrop, rhs.transform, rhs.visibleRegion, rhs.z, rhs.colorTransform, rhs.brightness, rhs.perFrameMetadata, rhs.perFrameMetadataBlob, rhs.blockingRegion, rhs.bufferSlotsToClear);
  }
  inline bool operator==(const LayerCommand& rhs) const {
    return std::tie(layer, cursorPosition, buffer, damage, blendMode, color, composition, dataspace, displayFrame, planeAlpha, sidebandStream, sourceCrop, transform, visibleRegion, z, colorTransform, brightness, perFrameMetadata, perFrameMetadataBlob, blockingRegion, bufferSlotsToClear) == std::tie(rhs.layer, rhs.cursorPosition, rhs.buffer, rhs.damage, rhs.blendMode, rhs.color, rhs.composition, rhs.dataspace, rhs.displayFrame, rhs.planeAlpha, rhs.sidebandStream, rhs.sourceCrop, rhs.transform, rhs.visibleRegion, rhs.z, rhs.colorTransform, rhs.brightness, rhs.perFrameMetadata, rhs.perFrameMetadataBlob, rhs.blockingRegion, rhs.bufferSlotsToClear);
  }
  inline bool operator>(const LayerCommand& rhs) const {
    return std::tie(layer, cursorPosition, buffer, damage, blendMode, color, composition, dataspace, displayFrame, planeAlpha, sidebandStream, sourceCrop, transform, visibleRegion, z, colorTransform, brightness, perFrameMetadata, perFrameMetadataBlob, blockingRegion, bufferSlotsToClear) > std::tie(rhs.layer, rhs.cursorPosition, rhs.buffer, rhs.damage, rhs.blendMode, rhs.color, rhs.composition, rhs.dataspace, rhs.displayFrame, rhs.planeAlpha, rhs.sidebandStream, rhs.sourceCrop, rhs.transform, rhs.visibleRegion, rhs.z, rhs.colorTransform, rhs.brightness, rhs.perFrameMetadata, rhs.perFrameMetadataBlob, rhs.blockingRegion, rhs.bufferSlotsToClear);
  }
  inline bool operator>=(const LayerCommand& rhs) const {
    return std::tie(layer, cursorPosition, buffer, damage, blendMode, color, composition, dataspace, displayFrame, planeAlpha, sidebandStream, sourceCrop, transform, visibleRegion, z, colorTransform, brightness, perFrameMetadata, perFrameMetadataBlob, blockingRegion, bufferSlotsToClear) >= std::tie(rhs.layer, rhs.cursorPosition, rhs.buffer, rhs.damage, rhs.blendMode, rhs.color, rhs.composition, rhs.dataspace, rhs.displayFrame, rhs.planeAlpha, rhs.sidebandStream, rhs.sourceCrop, rhs.transform, rhs.visibleRegion, rhs.z, rhs.colorTransform, rhs.brightness, rhs.perFrameMetadata, rhs.perFrameMetadataBlob, rhs.blockingRegion, rhs.bufferSlotsToClear);
  }

  static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
  inline std::string toString() const {
    std::ostringstream os;
    os << "LayerCommand{";
    os << "layer: " << ::android::internal::ToString(layer);
    os << ", cursorPosition: " << ::android::internal::ToString(cursorPosition);
    os << ", buffer: " << ::android::internal::ToString(buffer);
    os << ", damage: " << ::android::internal::ToString(damage);
    os << ", blendMode: " << ::android::internal::ToString(blendMode);
    os << ", color: " << ::android::internal::ToString(color);
    os << ", composition: " << ::android::internal::ToString(composition);
    os << ", dataspace: " << ::android::internal::ToString(dataspace);
    os << ", displayFrame: " << ::android::internal::ToString(displayFrame);
    os << ", planeAlpha: " << ::android::internal::ToString(planeAlpha);
    os << ", sidebandStream: " << ::android::internal::ToString(sidebandStream);
    os << ", sourceCrop: " << ::android::internal::ToString(sourceCrop);
    os << ", transform: " << ::android::internal::ToString(transform);
    os << ", visibleRegion: " << ::android::internal::ToString(visibleRegion);
    os << ", z: " << ::android::internal::ToString(z);
    os << ", colorTransform: " << ::android::internal::ToString(colorTransform);
    os << ", brightness: " << ::android::internal::ToString(brightness);
    os << ", perFrameMetadata: " << ::android::internal::ToString(perFrameMetadata);
    os << ", perFrameMetadataBlob: " << ::android::internal::ToString(perFrameMetadataBlob);
    os << ", blockingRegion: " << ::android::internal::ToString(blockingRegion);
    os << ", bufferSlotsToClear: " << ::android::internal::ToString(bufferSlotsToClear);
    os << "}";
    return os.str();
  }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

DisplayCommand 的实现如下：

class DisplayCommand {
public:
  typedef std::false_type fixed_size;
  static const char* descriptor;

  int64_t display = 0L;
  // 数据部分
  std::vector<::aidl::android::hardware::graphics::composer3::LayerCommand> layers;
  std::optional<std::vector<float>> colorTransformMatrix;
  std::optional<::aidl::android::hardware::graphics::composer3::DisplayBrightness> brightness;
  std::optional<::aidl::android::hardware::graphics::composer3::ClientTarget> clientTarget;
  std::optional<::aidl::android::hardware::graphics::composer3::Buffer> virtualDisplayOutputBuffer;
  std::optional<::aidl::android::hardware::graphics::composer3::ClockMonotonicTimestamp> expectedPresentTime;
  bool validateDisplay = false;
  bool acceptDisplayChanges = false;
  bool presentDisplay = false;
  bool presentOrValidateDisplay = false;

  binder_status_t readFromParcel(const AParcel* parcel);
  binder_status_t writeToParcel(AParcel* parcel) const;

  inline bool operator!=(const DisplayCommand& rhs) const {
    return std::tie(display, layers, colorTransformMatrix, brightness, clientTarget, virtualDisplayOutputBuffer, expectedPresentTime, validateDisplay, acceptDisplayChanges, presentDisplay, presentOrValidateDisplay) != std::tie(rhs.display, rhs.layers, rhs.colorTransformMatrix, rhs.brightness, rhs.clientTarget, rhs.virtualDisplayOutputBuffer, rhs.expectedPresentTime, rhs.validateDisplay, rhs.acceptDisplayChanges, rhs.presentDisplay, rhs.presentOrValidateDisplay);
  }
  inline bool operator<(const DisplayCommand& rhs) const {
    return std::tie(display, layers, colorTransformMatrix, brightness, clientTarget, virtualDisplayOutputBuffer, expectedPresentTime, validateDisplay, acceptDisplayChanges, presentDisplay, presentOrValidateDisplay) < std::tie(rhs.display, rhs.layers, rhs.colorTransformMatrix, rhs.brightness, rhs.clientTarget, rhs.virtualDisplayOutputBuffer, rhs.expectedPresentTime, rhs.validateDisplay, rhs.acceptDisplayChanges, rhs.presentDisplay, rhs.presentOrValidateDisplay);
  }
  inline bool operator<=(const DisplayCommand& rhs) const {
    return std::tie(display, layers, colorTransformMatrix, brightness, clientTarget, virtualDisplayOutputBuffer, expectedPresentTime, validateDisplay, acceptDisplayChanges, presentDisplay, presentOrValidateDisplay) <= std::tie(rhs.display, rhs.layers, rhs.colorTransformMatrix, rhs.brightness, rhs.clientTarget, rhs.virtualDisplayOutputBuffer, rhs.expectedPresentTime, rhs.validateDisplay, rhs.acceptDisplayChanges, rhs.presentDisplay, rhs.presentOrValidateDisplay);
  }
  inline bool operator==(const DisplayCommand& rhs) const {
    return std::tie(display, layers, colorTransformMatrix, brightness, clientTarget, virtualDisplayOutputBuffer, expectedPresentTime, validateDisplay, acceptDisplayChanges, presentDisplay, presentOrValidateDisplay) == std::tie(rhs.display, rhs.layers, rhs.colorTransformMatrix, rhs.brightness, rhs.clientTarget, rhs.virtualDisplayOutputBuffer, rhs.expectedPresentTime, rhs.validateDisplay, rhs.acceptDisplayChanges, rhs.presentDisplay, rhs.presentOrValidateDisplay);
  }
  inline bool operator>(const DisplayCommand& rhs) const {
    return std::tie(display, layers, colorTransformMatrix, brightness, clientTarget, virtualDisplayOutputBuffer, expectedPresentTime, validateDisplay, acceptDisplayChanges, presentDisplay, presentOrValidateDisplay) > std::tie(rhs.display, rhs.layers, rhs.colorTransformMatrix, rhs.brightness, rhs.clientTarget, rhs.virtualDisplayOutputBuffer, rhs.expectedPresentTime, rhs.validateDisplay, rhs.acceptDisplayChanges, rhs.presentDisplay, rhs.presentOrValidateDisplay);
  }
  inline bool operator>=(const DisplayCommand& rhs) const {
    return std::tie(display, layers, colorTransformMatrix, brightness, clientTarget, virtualDisplayOutputBuffer, expectedPresentTime, validateDisplay, acceptDisplayChanges, presentDisplay, presentOrValidateDisplay) >= std::tie(rhs.display, rhs.layers, rhs.colorTransformMatrix, rhs.brightness, rhs.clientTarget, rhs.virtualDisplayOutputBuffer, rhs.expectedPresentTime, rhs.validateDisplay, rhs.acceptDisplayChanges, rhs.presentDisplay, rhs.presentOrValidateDisplay);
  }

  static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
  inline std::string toString() const {
    std::ostringstream os;
    os << "DisplayCommand{";
    os << "display: " << ::android::internal::ToString(display);
    os << ", layers: " << ::android::internal::ToString(layers);
    os << ", colorTransformMatrix: " << ::android::internal::ToString(colorTransformMatrix);
    os << ", brightness: " << ::android::internal::ToString(brightness);
    os << ", clientTarget: " << ::android::internal::ToString(clientTarget);
    os << ", virtualDisplayOutputBuffer: " << ::android::internal::ToString(virtualDisplayOutputBuffer);
    os << ", expectedPresentTime: " << ::android::internal::ToString(expectedPresentTime);
    os << ", validateDisplay: " << ::android::internal::ToString(validateDisplay);
    os << ", acceptDisplayChanges: " << ::android::internal::ToString(acceptDisplayChanges);
    os << ", presentDisplay: " << ::android::internal::ToString(presentDisplay);
    os << ", presentOrValidateDisplay: " << ::android::internal::ToString(presentOrValidateDisplay);
    os << "}";
    return os.str();
  }
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

一堆的设置方法，都是在配置 mDisplayCommand 和 mLayerCommand。当要发起远程调用时，调用两个 flush 函数，mLayerCommand 插入到 mDisplayCommand->layers 中，mDisplayCommand 插入到 mCommands 中。当执行 aidlComposer::execute 时，会发起 binder 远程调用，使用 mCommands 作为参数：

Error AidlComposer::execute(Display display) {
    auto writer = getWriter(display);
    auto reader = getReader(display);
    if (!writer || !reader) {
        return Error::BAD_DISPLAY;
    }

    // 这里就是返回的 mCommands 中存储的内容
    auto commands = writer->get().takePendingCommands();
    if (commands.empty()) {
        return Error::NONE;
    }

    { // scope for results
        // 远程调用返回的结果
        std::vector<CommandResultPayload> results;
        // 发起远程调用，传入了 commands
        auto status = mAidlComposerClient->executeCommands(commands, &results);
        if (!status.isOk()) {
            ALOGE("executeCommands failed %s", status.getDescription().c_str());
            return static_cast<Error>(status.getServiceSpecificError());
        }

        // 通过 reader 解析结果
        reader->get().parse(std::move(results));
    }
    const auto commandErrors = reader->get().takeErrors();
    Error error = Error::NONE;
    for (const auto& cmdErr : commandErrors) {
        const auto index = static_cast<size_t>(cmdErr.commandIndex);
        if (index < 0 || index >= commands.size()) {
            ALOGE("invalid command index %zu", index);
            return Error::BAD_PARAMETER;
        }

        const auto& command = commands[index];
        if (command.validateDisplay || command.presentDisplay || command.presentOrValidateDisplay) {
            error = translate<Error>(cmdErr.errorCode);
        } else {
            ALOGW("command '%s' generated error %" PRId32, command.toString().c_str(),
                  cmdErr.errorCode);
        }
    }

    return error;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

返回结果 CommandResultPayload 的定义如下：

class CommandResultPayload {
public:
  typedef std::false_type fixed_size;
  static const char* descriptor;

  enum class Tag : int32_t {
    error = 0,
    changedCompositionTypes = 1,
    displayRequest = 2,
    presentFence = 3,
    releaseFences = 4,
    presentOrValidateResult = 5,
    clientTargetProperty = 6,
  };

  // Expose tag symbols for legacy code
  static const inline Tag error = Tag::error;
  static const inline Tag changedCompositionTypes = Tag::changedCompositionTypes;
  static const inline Tag displayRequest = Tag::displayRequest;
  static const inline Tag presentFence = Tag::presentFence;
  static const inline Tag releaseFences = Tag::releaseFences;
  static const inline Tag presentOrValidateResult = Tag::presentOrValidateResult;
  static const inline Tag clientTargetProperty = Tag::clientTargetProperty;

  template<typename _Tp>
  static constexpr bool _not_self = !std::is_same_v<std::remove_cv_t<std::remove_reference_t<_Tp>>, CommandResultPayload>;

  CommandResultPayload() : _value(std::in_place_index<static_cast<size_t>(error)>, ::aidl::android::hardware::graphics::composer3::CommandError()) { }

  template <typename _Tp, typename = std::enable_if_t<_not_self<_Tp>>>
  // NOLINTNEXTLINE(google-explicit-constructor)
  constexpr CommandResultPayload(_Tp&& _arg)
      : _value(std::forward<_Tp>(_arg)) {}

  template <size_t _Np, typename... _Tp>
  constexpr explicit CommandResultPayload(std::in_place_index_t<_Np>, _Tp&&... _args)
      : _value(std::in_place_index<_Np>, std::forward<_Tp>(_args)...) {}

  template <Tag _tag, typename... _Tp>
  static CommandResultPayload make(_Tp&&... _args) {
    return CommandResultPayload(std::in_place_index<static_cast<size_t>(_tag)>, std::forward<_Tp>(_args)...);
  }

  template <Tag _tag, typename _Tp, typename... _Up>
  static CommandResultPayload make(std::initializer_list<_Tp> _il, _Up&&... _args) {
    return CommandResultPayload(std::in_place_index<static_cast<size_t>(_tag)>, std::move(_il), std::forward<_Up>(_args)...);
  }

  Tag getTag() const {
    return static_cast<Tag>(_value.index());
  }

  template <Tag _tag>
  const auto& get() const {
    if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); }
    return std::get<static_cast<size_t>(_tag)>(_value);
  }

  template <Tag _tag>
  auto& get() {
    if (getTag() != _tag) { __assert2(__FILE__, __LINE__, __PRETTY_FUNCTION__, "bad access: a wrong tag"); }
    return std::get<static_cast<size_t>(_tag)>(_value);
  }

  template <Tag _tag, typename... _Tp>
  void set(_Tp&&... _args) {
    _value.emplace<static_cast<size_t>(_tag)>(std::forward<_Tp>(_args)...);
  }

  binder_status_t readFromParcel(const AParcel* _parcel);
  binder_status_t writeToParcel(AParcel* _parcel) const;

  inline bool operator!=(const CommandResultPayload& rhs) const {
    return _value != rhs._value;
  }
  inline bool operator<(const CommandResultPayload& rhs) const {
    return _value < rhs._value;
  }
  inline bool operator<=(const CommandResultPayload& rhs) const {
    return _value <= rhs._value;
  }
  inline bool operator==(const CommandResultPayload& rhs) const {
    return _value == rhs._value;
  }
  inline bool operator>(const CommandResultPayload& rhs) const {
    return _value > rhs._value;
  }
  inline bool operator>=(const CommandResultPayload& rhs) const {
    return _value >= rhs._value;
  }

  static const ::ndk::parcelable_stability_t _aidl_stability = ::ndk::STABILITY_VINTF;
  inline std::string toString() const {
    std::ostringstream os;
    os << "CommandResultPayload{";
    switch (getTag()) {
    case error: os << "error: " << ::android::internal::ToString(get<error>()); break;
    case changedCompositionTypes: os << "changedCompositionTypes: " << ::android::internal::ToString(get<changedCompositionTypes>()); break;
    case displayRequest: os << "displayRequest: " << ::android::internal::ToString(get<displayRequest>()); break;
    case presentFence: os << "presentFence: " << ::android::internal::ToString(get<presentFence>()); break;
    case releaseFences: os << "releaseFences: " << ::android::internal::ToString(get<releaseFences>()); break;
    case presentOrValidateResult: os << "presentOrValidateResult: " << ::android::internal::ToString(get<presentOrValidateResult>()); break;
    case clientTargetProperty: os << "clientTargetProperty: " << ::android::internal::ToString(get<clientTargetProperty>()); break;
    }
    os << "}";
    return os.str();
  }
private:
  std::variant<::aidl::android::hardware::graphics::composer3::CommandError, ::aidl::android::hardware::graphics::composer3::ChangedCompositionTypes, ::aidl::android::hardware::graphics::composer3::DisplayRequest, ::aidl::android::hardware::graphics::composer3::PresentFence, ::aidl::android::hardware::graphics::composer3::ReleaseFences, ::aidl::android::hardware::graphics::composer3::PresentOrValidate, ::aidl::android::hardware::graphics::composer3::ClientTargetPropertyWithBrightness> _value;
};

主要的数据就是最后的 variant 变量。

我们来看 reader 是如何解析的。

ComposerClientReader 的定义如下，主要看下 parse 的实现：

class ComposerClientReader {
  public:
    explicit ComposerClientReader(std::optional<int64_t> display = {}) : mDisplay(display) {}

    ~ComposerClientReader() { resetData(); }

    ComposerClientReader(ComposerClientReader&&) = default;

    ComposerClientReader(const ComposerClientReader&) = delete;
    ComposerClientReader& operator=(const ComposerClientReader&) = delete;

    // Parse and execute commands from the command queue.  The commands are
    // actually return values from the server and will be saved in ReturnData.
    void parse(std::vector<CommandResultPayload>&& results) {
        resetData();

        for (auto& result : results) {
            // 根据不同的 tag，调用不同的方法解析
            switch (result.getTag()) {
                case CommandResultPayload::Tag::error:
                    parseSetError(std::move(result.get<CommandResultPayload::Tag::error>()));
                    break;
                case CommandResultPayload::Tag::changedCompositionTypes:
                    parseSetChangedCompositionTypes(std::move(
                            result.get<CommandResultPayload::Tag::changedCompositionTypes>()));
                    break;
                case CommandResultPayload::Tag::displayRequest:
                    parseSetDisplayRequests(
                            std::move(result.get<CommandResultPayload::Tag::displayRequest>()));
                    break;
                case CommandResultPayload::Tag::presentFence:
                    parseSetPresentFence(
                            std::move(result.get<CommandResultPayload::Tag::presentFence>()));
                    break;
                case CommandResultPayload::Tag::releaseFences:
                    parseSetReleaseFences(
                            std::move(result.get<CommandResultPayload::Tag::releaseFences>()));
                    break;
                case CommandResultPayload::Tag::presentOrValidateResult:
                    parseSetPresentOrValidateDisplayResult(std::move(
                            result.get<CommandResultPayload::Tag::presentOrValidateResult>()));
                    break;
                case CommandResultPayload::Tag::clientTargetProperty:
                    parseSetClientTargetProperty(std::move(
                            result.get<CommandResultPayload::Tag::clientTargetProperty>()));
                    break;
            }
        }
    }

    std::vector<CommandError> takeErrors() { return std::move(mErrors); }

    void hasChanges(int64_t display, uint32_t* outNumChangedCompositionTypes,
                    uint32_t* outNumLayerRequestMasks) const {
        LOG_ALWAYS_FATAL_IF(mDisplay && display != *mDisplay);
        auto found = mReturnData.find(display);
        if (found == mReturnData.end()) {
            *outNumChangedCompositionTypes = 0;
            *outNumLayerRequestMasks = 0;
            return;
        }

        const ReturnData& data = found->second;

        *outNumChangedCompositionTypes = static_cast<uint32_t>(data.changedLayers.size());
        *outNumLayerRequestMasks = static_cast<uint32_t>(data.displayRequests.layerRequests.size());
    }

    // Get and clear saved changed composition types.
    std::vector<ChangedCompositionLayer> takeChangedCompositionTypes(int64_t display) {
        LOG_ALWAYS_FATAL_IF(mDisplay && display != *mDisplay);
        auto found = mReturnData.find(display);
        if (found == mReturnData.end()) {
            return {};
        }

        ReturnData& data = found->second;
        return std::move(data.changedLayers);
    }

    // Get and clear saved display requests.
    DisplayRequest takeDisplayRequests(int64_t display) {
        LOG_ALWAYS_FATAL_IF(mDisplay && display != *mDisplay);
        auto found = mReturnData.find(display);
        if (found == mReturnData.end()) {
            return {};
        }

        ReturnData& data = found->second;
        return std::move(data.displayRequests);
    }

    // Get and clear saved release fences.
    std::vector<ReleaseFences::Layer> takeReleaseFences(int64_t display) {
        LOG_ALWAYS_FATAL_IF(mDisplay && display != *mDisplay);
        auto found = mReturnData.find(display);
        if (found == mReturnData.end()) {
            return {};
        }

        ReturnData& data = found->second;
        return std::move(data.releasedLayers);
    }

    // Get and clear saved present fence.
    ndk::ScopedFileDescriptor takePresentFence(int64_t display) {
        LOG_ALWAYS_FATAL_IF(mDisplay && display != *mDisplay);
        auto found = mReturnData.find(display);
        if (found == mReturnData.end()) {
            return {};
        }

        ReturnData& data = found->second;
        return std::move(data.presentFence);
    }

    // Get what stage succeeded during PresentOrValidate: Present or Validate
    std::optional<PresentOrValidate::Result> takePresentOrValidateStage(int64_t display) {
        LOG_ALWAYS_FATAL_IF(mDisplay && display != *mDisplay);
        auto found = mReturnData.find(display);
        if (found == mReturnData.end()) {
            return std::nullopt;
        }
        ReturnData& data = found->second;
        return data.presentOrValidateState;
    }

    // Get the client target properties requested by hardware composer.
    ClientTargetPropertyWithBrightness takeClientTargetProperty(int64_t display) {
        LOG_ALWAYS_FATAL_IF(mDisplay && display != *mDisplay);
        auto found = mReturnData.find(display);

        // If not found, return the default values.
        if (found == mReturnData.end()) {
            return ClientTargetPropertyWithBrightness{
                    .clientTargetProperty = {common::PixelFormat::RGBA_8888, Dataspace::UNKNOWN},
                    .brightness = 1.f,
            };
        }

        ReturnData& data = found->second;
        return std::move(data.clientTargetProperty);
    }

  private:
    void resetData() {
        mErrors.clear();
        mReturnData.clear();
    }

    void parseSetError(CommandError&& error) { mErrors.emplace_back(error); }

    void parseSetChangedCompositionTypes(ChangedCompositionTypes&& changedCompositionTypes) {
        LOG_ALWAYS_FATAL_IF(mDisplay && changedCompositionTypes.display != *mDisplay);
        auto& data = mReturnData[changedCompositionTypes.display];
        data.changedLayers = std::move(changedCompositionTypes.layers);
    }

    void parseSetDisplayRequests(DisplayRequest&& displayRequest) {
        LOG_ALWAYS_FATAL_IF(mDisplay && displayRequest.display != *mDisplay);
        auto& data = mReturnData[displayRequest.display];
        data.displayRequests = std::move(displayRequest);
    }

    void parseSetPresentFence(PresentFence&& presentFence) {
        LOG_ALWAYS_FATAL_IF(mDisplay && presentFence.display != *mDisplay);
        auto& data = mReturnData[presentFence.display];
        data.presentFence = std::move(presentFence.fence);
    }

    void parseSetReleaseFences(ReleaseFences&& releaseFences) {
        LOG_ALWAYS_FATAL_IF(mDisplay && releaseFences.display != *mDisplay);
        auto& data = mReturnData[releaseFences.display];
        data.releasedLayers = std::move(releaseFences.layers);
    }

    void parseSetPresentOrValidateDisplayResult(const PresentOrValidate&& presentOrValidate) {
        LOG_ALWAYS_FATAL_IF(mDisplay && presentOrValidate.display != *mDisplay);
        auto& data = mReturnData[presentOrValidate.display];
        data.presentOrValidateState = std::move(presentOrValidate.result);
    }

    void parseSetClientTargetProperty(
            const ClientTargetPropertyWithBrightness&& clientTargetProperty) {
        LOG_ALWAYS_FATAL_IF(mDisplay && clientTargetProperty.display != *mDisplay);
        auto& data = mReturnData[clientTargetProperty.display];
        data.clientTargetProperty = std::move(clientTargetProperty);
    }

    struct ReturnData {
        DisplayRequest displayRequests;
        std::vector<ChangedCompositionLayer> changedLayers;
        ndk::ScopedFileDescriptor presentFence;
        std::vector<ReleaseFences::Layer> releasedLayers;
        PresentOrValidate::Result presentOrValidateState;

        ClientTargetPropertyWithBrightness clientTargetProperty = {
                .clientTargetProperty = {common::PixelFormat::RGBA_8888, Dataspace::UNKNOWN},
                .brightness = 1.f,
        };
    };

    std::vector<CommandError> mErrors;
    std::unordered_map<int64_t, ReturnData> mReturnData;
    const std::optional<int64_t> mDisplay;
};

Reader 用于解析远程调用返回的数据。

问题，mWriters 和 mReader 什么时候添加数据的？

看下 AidlComposer 构造函数：

// /frameworks/native/services/surfaceflinger/DisplayHardware/AidlComposerHal.cpp
AidlComposer::AidlComposer(const std::string& serviceName) {
    // This only waits if the service is actually declared
    mAidlComposer = AidlIComposer::fromBinder(
            ndk::SpAIBinder(AServiceManager_waitForService(instance(serviceName).c_str())));
    if (!mAidlComposer) {
        LOG_ALWAYS_FATAL("Failed to get AIDL composer service");
        return;
    }

    if (!mAidlComposer->createClient(&mAidlComposerClient).isOk()) {
        LOG_ALWAYS_FATAL("Can't create AidlComposerClient, fallback to HIDL");
        return;
    }

    // 是不是添加 reader ？
    addReader(translate<Display>(kSingleReaderKey));

    // If unable to read interface version, then become backwards compatible.
    int32_t version = 1;
    const auto status = mAidlComposerClient->getInterfaceVersion(&version);
    if (!status.isOk()) {
        ALOGE("getInterfaceVersion for AidlComposer constructor failed %s",
              status.getDescription().c_str());
    }
    mSupportsBufferSlotsToClear = version > 1;
    if (!mSupportsBufferSlotsToClear) {
        if (sysprop::clear_slots_with_set_layer_buffer(false)) {
            mClearSlotBuffer = sp<GraphicBuffer>::make(1, 1, PIXEL_FORMAT_RGBX_8888,
                                                       GraphicBuffer::USAGE_HW_COMPOSER |
                                                               GraphicBuffer::USAGE_SW_READ_OFTEN |
                                                               GraphicBuffer::USAGE_SW_WRITE_OFTEN,
                                                       "AidlComposer");
            if (!mClearSlotBuffer || mClearSlotBuffer->initCheck() != ::android::OK) {
                LOG_ALWAYS_FATAL("Failed to allocate a buffer for clearing layer buffer slots");
                return;
            }
        }
    }

    ALOGI("Loaded AIDL composer3 HAL service");
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

void AidlComposer::addReader(Display display) {
    const auto displayId = translate<int64_t>(display);
    std::optional<int64_t> displayOpt;
    if (displayId != kSingleReaderKey) {
        displayOpt.emplace(displayId);
    }

    // 添加 reader
    auto [it, added] = mReaders.try_emplace(display, std::move(displayOpt));
    ALOGW_IF(!added, "Attempting to add writer for display %" PRId64 " which is already connected",
             displayId);
}

1
2
3
4
5
6
7
8
9
10
11
12

热插拔，or 初始化时：

void AidlComposer::onHotplugConnect(Display display) {
    addDisplay(display);
}

// 
void AidlComposer::addDisplay(Display display) {
    const auto displayId = translate<int64_t>(display);
    mMutex.lock();
    // 添加 writer
    auto [it, added] = mWriters.try_emplace(display, displayId);
    ALOGW_IF(!added, "Attempting to add writer for display %" PRId64 " which is already connected",
             displayId);
    if (mSingleReader) {
        if (hasMultiThreadedPresentSupport(display)) {
            mSingleReader = false;
            removeReader(translate<Display>(kSingleReaderKey));
            // Note that this includes the new display.
            for (const auto& [existingDisplay, _] : mWriters) {
                addReader(existingDisplay);
            }
        }
    } else {
        addReader(display);
    }
    mMutex.unlock();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 7.2.2 关注点1，updateCompositionState

关注点1，updateCompositionState 会调用所有 OutputLayer 的 updateCompositionState 来更新数据：

void Output::updateCompositionState(const compositionengine::CompositionRefreshArgs& refreshArgs) {
    ATRACE_CALL();
    ALOGV(__FUNCTION__);

    if (!getState().isEnabled) {
        return;
    }

    mLayerRequestingBackgroundBlur = findLayerRequestingBackgroundComposition();
    bool forceClientComposition = mLayerRequestingBackgroundBlur != nullptr;

    for (auto* layer : getOutputLayersOrderedByZ()) {
        layer->updateCompositionState(refreshArgs.updatingGeometryThisFrame,
                                      refreshArgs.devOptForceClientComposition ||
                                              forceClientComposition,
                                      refreshArgs.internalDisplayRotationFlags);

        if (mLayerRequestingBackgroundBlur == layer) {
            forceClientComposition = false;
        }
    }

    updateCompositionStateForBorder(refreshArgs);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

遍历调用每个 OutputLayer 的 updateCompositionState，更新每个 OutputLayer 的 state 的一些信息。然后还调用 updateCompositionStateForBorder 同步参数内每个 layer 的同步信息。我们的 Demo 涉及不到，具体细节我们就不看了。

void Output::updateCompositionState(const compositionengine::CompositionRefreshArgs& refreshArgs) {

    if (!getState().isEnabled) {
        return;
    }
    // forceClientComposition代表是否需要gpu合成，有模糊的layer这里返回就不为空，forceClientComposition为true
    mLayerRequestingBackgroundBlur = findLayerRequestingBackgroundComposition();
    bool forceClientComposition = mLayerRequestingBackgroundBlur != nullptr;

    for (auto* layer : getOutputLayersOrderedByZ()) {
        // 遍历素有 OutputLayer,调用 updateCompositionState
        layer->updateCompositionState(refreshArgs.updatingGeometryThisFrame,
                                    refreshArgs.devOptForceClientComposition ||
                                            forceClientComposition,
                                    refreshArgs.internalDisplayRotationFlags);
        // 当layer == mLayerRequestingBackgroundBlur，表示后面的layer已经没有模糊的layer，就不需要强制gpu合成。
        if (mLayerRequestingBackgroundBlur == layer) {
            forceClientComposition = false;
        }
    }
    // 将refreshArgs里面layer的边界信息同步到OutputCompositionState的borderInfoList列表里。
    updateCompositionStateForBorder(refreshArgs);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 7.2.3 writeCompositionState

关注点 2 writeCompositionState：

void Output::writeCompositionState(const compositionengine::CompositionRefreshArgs& refreshArgs) {
    ATRACE_CALL();
    ALOGV(__FUNCTION__);

    if (!getState().isEnabled) {
        return;
    }

    editState().earliestPresentTime = refreshArgs.earliestPresentTime;
    editState().expectedPresentTime = refreshArgs.expectedPresentTime;

    compositionengine::OutputLayer* peekThroughLayer = nullptr;
    sp<GraphicBuffer> previousOverride = nullptr;
    bool includeGeometry = refreshArgs.updatingGeometryThisFrame;
    uint32_t z = 0;
    bool overrideZ = false;
    uint64_t outputLayerHash = 0;
    // 遍历所有的 OutputLayer
    for (auto* layer : getOutputLayersOrderedByZ()) {
        if (layer == peekThroughLayer) {
            // No longer needed, although it should not show up again, so
            // resetting it is not truly needed either.
            peekThroughLayer = nullptr;

            // peekThroughLayer was already drawn ahead of its z order.
            continue;
        }
        bool skipLayer = false;
        const auto& overrideInfo = layer->getState().overrideInfo;
        if (overrideInfo.buffer != nullptr) {
            if (previousOverride && overrideInfo.buffer->getBuffer() == previousOverride) {
                ALOGV("Skipping redundant buffer");
                skipLayer = true;
            } else {
                // First layer with the override buffer.
                if (overrideInfo.peekThroughLayer) {
                    peekThroughLayer = overrideInfo.peekThroughLayer;

                    // Draw peekThroughLayer first.
                    overrideZ = true;
                    includeGeometry = true;
                    constexpr bool isPeekingThrough = true;
                    peekThroughLayer->writeStateToHWC(includeGeometry, false, z++, overrideZ,
                                                      isPeekingThrough);
                    outputLayerHash ^= android::hashCombine(
                            reinterpret_cast<uint64_t>(&peekThroughLayer->getLayerFE()),
                            z, includeGeometry, overrideZ, isPeekingThrough,
                            peekThroughLayer->requiresClientComposition());
                }

                previousOverride = overrideInfo.buffer->getBuffer();
            }
        }

        constexpr bool isPeekingThrough = false;
        // 关注点
        layer->writeStateToHWC(includeGeometry, skipLayer, z++, overrideZ, isPeekingThrough);
        if (!skipLayer) {
            outputLayerHash ^= android::hashCombine(
                    reinterpret_cast<uint64_t>(&layer->getLayerFE()),
                    z, includeGeometry, overrideZ, isPeekingThrough,
                    layer->requiresClientComposition());
        }
    }
    editState().outputLayerHash = outputLayerHash;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

遍历所有的 OutputLayer，然后调用每一个 OutputLayer 的 writeStateToHWC 函数：

void OutputLayer::writeStateToHWC(bool includeGeometry, bool skipLayer, uint32_t z,
                                  bool zIsOverridden, bool isPeekingThrough) {
    const auto& state = getState();
    // Skip doing this if there is no HWC interface
    if (!state.hwc) {
        return;
    }

    //拿到 OutputLayer 对应的 hwclayer
    auto& hwcLayer = (*state.hwc).hwcLayer;
    if (!hwcLayer) {
        ALOGE("[%s] failed to write composition state to HWC -- no hwcLayer for output %s",
              getLayerFE().getDebugName(), getOutput().getName().c_str());
        return;
    }

    const auto* outputIndependentState = getLayerFE().getCompositionState();
    if (!outputIndependentState) {
        return;
    }

    auto requestedCompositionType = outputIndependentState->compositionType;

    if (requestedCompositionType == Composition::SOLID_COLOR && state.overrideInfo.buffer) {
        // this should never happen, as SOLID_COLOR is skipped from caching, b/230073351
        requestedCompositionType = Composition::DEVICE;
    }

    // TODO(b/181172795): We now update geometry for all flattened layers. We should update it
    // only when the geometry actually changes
    const bool isOverridden =
            state.overrideInfo.buffer != nullptr || isPeekingThrough || zIsOverridden;
    const bool prevOverridden = state.hwc->stateOverridden;
    if (isOverridden || prevOverridden || skipLayer || includeGeometry) {
        writeOutputDependentGeometryStateToHWC(hwcLayer.get(), requestedCompositionType, z);
        writeOutputIndependentGeometryStateToHWC(hwcLayer.get(), *outputIndependentState,
                                                 skipLayer);
    }

    // 写数据到 hwc
    writeOutputDependentPerFrameStateToHWC(hwcLayer.get());
  
    writeOutputIndependentPerFrameStateToHWC(hwcLayer.get(), *outputIndependentState,
                                             requestedCompositionType, skipLayer);

    writeCompositionTypeToHWC(hwcLayer.get(), requestedCompositionType, isPeekingThrough,
                              skipLayer);

    if (requestedCompositionType == Composition::SOLID_COLOR) {
        writeSolidColorStateToHWC(hwcLayer.get(), *outputIndependentState);
    }

    editState().hwc->stateOverridden = isOverridden;
    editState().hwc->layerSkipped = skipLayer;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

writeOutputDependentPerFrameStateToHWC、writeOutputIndependentPerFrameStateToHWC、writeCompositionTypeToHWC、writeSolidColorStateToHWC 四个函数都是用于写数据到 hwc，逻辑大体一样，我们一个个看：

void OutputLayer::writeOutputDependentPerFrameStateToHWC(HWC2::Layer* hwcLayer) {
    const auto& outputDependentState = getState();

    // TODO(lpique): b/121291683 outputSpaceVisibleRegion is output-dependent geometry
    // state and should not change every frame.
    Region visibleRegion = outputDependentState.overrideInfo.buffer
            ? Region(outputDependentState.overrideInfo.visibleRegion)
            : outputDependentState.outputSpaceVisibleRegion;
  
    // 关注点
    if (auto error = hwcLayer->setVisibleRegion(visibleRegion); error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set visible region: %s (%d)", getLayerFE().getDebugName(),
              to_string(error).c_str(), static_cast<int32_t>(error));
        visibleRegion.dump(LOG_TAG);
    }

    // 关注点
    if (auto error =
                hwcLayer->setBlockingRegion(outputDependentState.outputSpaceBlockingRegionHint);
        error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set blocking region: %s (%d)", getLayerFE().getDebugName(),
              to_string(error).c_str(), static_cast<int32_t>(error));
        outputDependentState.outputSpaceBlockingRegionHint.dump(LOG_TAG);
    }

    const auto dataspace = outputDependentState.overrideInfo.buffer
            ? outputDependentState.overrideInfo.dataspace
            : outputDependentState.dataspace;

    // 关注点
    if (auto error = hwcLayer->setDataspace(dataspace); error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set dataspace %d: %s (%d)", getLayerFE().getDebugName(), dataspace,
              to_string(error).c_str(), static_cast<int32_t>(error));
    }

    // Cached layers are not dimmed, which means that composer should attempt to dim.
    // Note that if the dimming ratio is large, then this may cause the cached layer
    // to kick back into GPU composition :(
    // Also note that this assumes that there are no HDR layers that are able to be cached.
    // Otherwise, this could cause HDR layers to be dimmed twice.
    const auto dimmingRatio = outputDependentState.overrideInfo.buffer
            ? (getOutput().getState().displayBrightnessNits != 0.f
                       ? std::clamp(getOutput().getState().sdrWhitePointNits /
                                            getOutput().getState().displayBrightnessNits,
                                    0.f, 1.f)
                       : 1.f)
            : outputDependentState.dimmingRatio;

    // 关注点
    if (auto error = hwcLayer->setBrightness(dimmingRatio); error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set brightness %f: %s (%d)", getLayerFE().getDebugName(),
              dimmingRatio, to_string(error).c_str(), static_cast<int32_t>(error));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

hwcLayer->setVisibleRegion：设置到 writer 中的 LayerCommand 的 visibleRegion
hwcLayer->setBlockingRegion：设置到 writer 中的 LayerCommand 的 blockingRegion
hwcLayer->setDataspace：设置到 writer 中的 LayerCommand 的 dataspace
hwcLayer->setBrightness：设置到 writer 中的 LayerCommand 的 brightness

逻辑都是一样的，我们就看一个：

Error Layer::setVisibleRegion(const Region& region)
{
    if (CC_UNLIKELY(!mDisplay)) {
        return Error::BAD_DISPLAY;
    }

    if (region.isRect() && mVisibleRegion.isRect() &&
        (region.getBounds() == mVisibleRegion.getBounds())) {
        return Error::NONE;
    }
    mVisibleRegion = region;
    const auto hwcRects = convertRegionToHwcRects(region);
    auto intError = mComposer.setLayerVisibleRegion(mDisplay->getId(), mId, hwcRects);
    return static_cast<Error>(intError);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

接着调用 mComposer.setLayerVisibleRegion：

Error AidlComposer::setLayerVisibleRegion(Display display, Layer layer,
                                          const std::vector<IComposerClient::Rect>& visible) {
    Error error = Error::NONE;
    mMutex.lock_shared();
    if (auto writer = getWriter(display)) {
        writer->get().setLayerVisibleRegion(translate<int64_t>(display), translate<int64_t>(layer),
                                            translate<AidlRect>(visible));
    } else {
        error = Error::BAD_DISPLAY;
    }
    mMutex.unlock_shared();
    return error;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

    void setLayerVisibleRegion(int64_t display, int64_t layer, const std::vector<Rect>& visible) {
        getLayerCommand(display, layer).visibleRegion.emplace(visible.begin(), visible.end());
    }

1
2
3

接下来看 writeOutputIndependentPerFrameStateToHWC 的实现：

void OutputLayer::writeOutputIndependentPerFrameStateToHWC(
        HWC2::Layer* hwcLayer, const LayerFECompositionState& outputIndependentState,
        Composition compositionType, bool skipLayer) {
    // 关注点
    switch (auto error = hwcLayer->setColorTransform(outputIndependentState.colorTransform)) {
        case hal::Error::NONE:
            break;
        case hal::Error::UNSUPPORTED:
            editState().forceClientComposition = true;
            break;
        default:
            ALOGE("[%s] Failed to set color transform: %s (%d)", getLayerFE().getDebugName(),
                  to_string(error).c_str(), static_cast<int32_t>(error));
    }

    const Region& surfaceDamage = getState().overrideInfo.buffer
            ? getState().overrideInfo.damageRegion
            : (getState().hwc->stateOverridden ? Region::INVALID_REGION
                                               : outputIndependentState.surfaceDamage);

    // 关注点
    if (auto error = hwcLayer->setSurfaceDamage(surfaceDamage); error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set surface damage: %s (%d)", getLayerFE().getDebugName(),
              to_string(error).c_str(), static_cast<int32_t>(error));
        outputIndependentState.surfaceDamage.dump(LOG_TAG);
    }

    // Content-specific per-frame state
    switch (compositionType) {
        case Composition::SOLID_COLOR:
            // For compatibility, should be written AFTER the composition type.
            break;
        case Composition::SIDEBAND:
            writeSidebandStateToHWC(hwcLayer, outputIndependentState);
            break;
        case Composition::CURSOR:
        case Composition::DEVICE:  // device 合成走这里
        case Composition::DISPLAY_DECORATION:
        case Composition::REFRESH_RATE_INDICATOR:
            // 关注点
            writeBufferStateToHWC(hwcLayer, outputIndependentState, skipLayer);
            break;
        case Composition::INVALID:
        case Composition::CLIENT:
            // Ignored
            break;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

hwcLayer->setColorTransform
hwcLayer->setSurfaceDamage
writeSidebandStateToHWC
writeBufferStateToHWC

写数据到 hwc，逻辑类似，挑 writeBufferStateToHWC 看看：

// /frameworks/native/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp
void OutputLayer::writeBufferStateToHWC(HWC2::Layer* hwcLayer,
                                        const LayerFECompositionState& outputIndependentState,
                                        bool skipLayer) {
    auto supportedPerFrameMetadata =
            getOutput().getDisplayColorProfile()->getSupportedPerFrameMetadata();
    if (auto error = hwcLayer->setPerFrameMetadata(supportedPerFrameMetadata,
                                                   outputIndependentState.hdrMetadata);
        error != hal::Error::NONE && error != hal::Error::UNSUPPORTED) {
        ALOGE("[%s] Failed to set hdrMetadata: %s (%d)", getLayerFE().getDebugName(),
              to_string(error).c_str(), static_cast<int32_t>(error));
    }

    // 关注点 buffrer 的获取过程
    HwcSlotAndBuffer hwcSlotAndBuffer;
    sp<Fence> hwcFence;
    {
        // Editing the state only because we update the HWC buffer cache and active buffer.
        auto& state = editState();
        // Override buffers use a special cache slot so that they don't evict client buffers.
        if (state.overrideInfo.buffer != nullptr && !skipLayer) {
            hwcSlotAndBuffer = state.hwc->hwcBufferCache.getOverrideHwcSlotAndBuffer(
                    state.overrideInfo.buffer->getBuffer());
            hwcFence = state.overrideInfo.acquireFence;
            // Keep track of the active buffer ID so when it's discarded we uncache it last so its
            // slot will be used first, allowing the memory to be freed as soon as possible.
            state.hwc->activeBufferId = state.overrideInfo.buffer->getBuffer()->getId();
        } else {
            // hwcBufferCache 用于缓存优化，实际的 buffer 来自 outputIndependentState
            hwcSlotAndBuffer =
                    state.hwc->hwcBufferCache.getHwcSlotAndBuffer(outputIndependentState.buffer);
            hwcFence = outputIndependentState.acquireFence;
            // Keep track of the active buffer ID so when it's discarded we uncache it last so its
            // slot will be used first, allowing the memory to be freed as soon as possible.
            state.hwc->activeBufferId = outputIndependentState.buffer->getId();
        }
        // Keep track of the active buffer slot, so we can restore it after clearing other buffer
        // slots.
        state.hwc->activeBufferSlot = hwcSlotAndBuffer.slot;
    }
  
    // 关注点
    if (auto error = hwcLayer->setBuffer(hwcSlotAndBuffer.slot, hwcSlotAndBuffer.buffer, hwcFence);
        error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set buffer %p: %s (%d)", getLayerFE().getDebugName(),
              hwcSlotAndBuffer.buffer->handle, to_string(error).c_str(),
              static_cast<int32_t>(error));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

setBuffer 的实现如下：


Error Layer::setBuffer(uint32_t slot, const sp<GraphicBuffer>& buffer,
        const sp<Fence>& acquireFence)
{
    if (CC_UNLIKELY(!mDisplay)) {aidl
        return Error::BAD_DISPLAY;
    }

    if (buffer == nullptr && mBufferSlot == slot) {
        return Error::NONE;
    }
    mBufferSlot = slot;

    int32_t fenceFd = acquireFence->dup();
    auto intError = mComposer.setLayerBuffer(mDisplay->getId(), mId, slot, buffer, fenceFd);
    return static_cast<Error>(intError);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

接着调用到 mComposer.setLayerBuffer：

Error AidlComposer::setLayerBuffer(Display display, Layer layer, uint32_t slot,
                                   const sp<GraphicBuffer>& buffer, int acquireFence) {
    const native_handle_t* handle = nullptr;
    if (buffer.get()) {
        handle = buffer->getNativeBuffer()->handle;
    }

    Error error = Error::NONE;
    mMutex.lock_shared();
    if (auto writer = getWriter(display)) {
        writer->get().setLayerBuffer(translate<int64_t>(display), translate<int64_t>(layer), slot,
                                     handle, acquireFence);
    } else {
        error = Error::BAD_DISPLAY;
    }
    mMutex.unlock_shared();
    return error;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

看下 writer 的 setLayerBuffer：

    void setLayerBuffer(int64_t display, int64_t layer, uint32_t slot,
                        const native_handle_t* buffer, int acquireFence) {
        getLayerCommand(display, layer).buffer = getBufferCommand(slot, buffer, acquireFence);
    }

    Buffer getBufferCommand(uint32_t slot, const native_handle_t* bufferHandle, int fence) {
        Buffer bufferCommand;
        bufferCommand.slot = static_cast<int32_t>(slot);
        if (bufferHandle) bufferCommand.handle.emplace(::android::dupToAidl(bufferHandle));
        if (fence > 0) bufferCommand.fence = ::ndk::ScopedFileDescriptor(fence);
        return bufferCommand;
    }

    LayerCommand& getLayerCommand(int64_t display, int64_t layer) {
        getDisplayCommand(display);
        if (!mLayerCommand.has_value() || mLayerCommand->layer != layer) {
            flushLayerCommand();
            mLayerCommand.emplace();
            mLayerCommand->layer = layer;
        }
        return *mLayerCommand;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

实际就是把 buffer 保存到了 mLayerCommand 的 buffer 成员的 handle 成员中。

其他的设置都大体类似。

接着再来看 writeCompositionTypeToHWC 的实现：

void OutputLayer::writeCompositionTypeToHWC(HWC2::Layer* hwcLayer,
                                            Composition requestedCompositionType,
                                            bool isPeekingThrough, bool skipLayer) {
    auto& outputDependentState = editState();

    if (isClientCompositionForced(isPeekingThrough)) {
        // If we are forcing client composition, we need to tell the HWC
        requestedCompositionType = Composition::CLIENT;
    }

    // Set the requested composition type with the HWC whenever it changes
    // We also resend the composition type when this layer was previously skipped, to ensure that
    // the composition type is up-to-date.
    if (outputDependentState.hwc->hwcCompositionType != requestedCompositionType ||
        (outputDependentState.hwc->layerSkipped && !skipLayer)) {
        outputDependentState.hwc->hwcCompositionType = requestedCompositionType;

        // 关注点
        if (auto error = hwcLayer->setCompositionType(requestedCompositionType);
            error != hal::Error::NONE) {
            ALOGE("[%s] Failed to set composition type %s: %s (%d)", getLayerFE().getDebugName(),
                  to_string(requestedCompositionType).c_str(), to_string(error).c_str(),
                  static_cast<int32_t>(error));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

hwcLayer->setCompositionType，设置到 writer 中的 LayerCommand 的 composition。和前面一样，就不细看。

最后一个 writeSolidColorStateToHWC 和前面三个函数逻辑相同，就留给读者分析了。

# 7.2.4 prepareFrame

关注点3，prepareFrame 核心逻辑是选择合成策略，判断每个 Layer 是 device 还是 GPU 合成。与之同时会完成部分 device 合成。

// frameworks/native/services/surfaceflinger/CompositionEngin/src/Output.cpp

void Output::prepareFrame() {
    ATRACE_CALL();
    ALOGV(__FUNCTION__);

    auto& outputState = editState();
    if (!outputState.isEnabled) {
        return;
    }

    std::optional<android::HWComposer::DeviceRequestedChanges> changes;
    // 选择合成类型，device or client
    bool success = chooseCompositionStrategy(&changes);

    resetCompositionStrategy();
    outputState.strategyPrediction = CompositionStrategyPredictionState::DISABLED;
    outputState.previousDeviceRequestedChanges = changes;
    outputState.previousDeviceRequestedSuccess = success;
    if (success) {
        applyCompositionStrategy(changes);
    }
    finishPrepareFrame();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

重点是 chooseCompositionStrategy 函数：

bool Display::chooseCompositionStrategy(
        std::optional<android::HWComposer::DeviceRequestedChanges>* outChanges) {
    ATRACE_FORMAT("%s for %s", __func__, getNamePlusId().c_str());
    ALOGV(__FUNCTION__);

    if (mIsDisconnected) {
        return false;
    }

    // If we don't have a HWC display, then we are done.
    const auto halDisplayId = HalDisplayId::tryCast(mId);
    if (!halDisplayId) {
        return false;
    }

    // Get any composition changes requested by the HWC device, and apply them.
    std::optional<android::HWComposer::DeviceRequestedChanges> changes;
    auto& hwc = getCompositionEngine().getHwComposer();

    // 关注点
    const bool requiresClientComposition = anyLayersRequireClientComposition();

    if (isPowerHintSessionEnabled()) {
        mPowerAdvisor->setRequiresClientComposition(mId, requiresClientComposition);
    }

    const TimePoint hwcValidateStartTime = TimePoint::now();

    // 关注点
    if (status_t result =
                hwc.getDeviceCompositionChanges(*halDisplayId, requiresClientComposition,
                                                getState().earliestPresentTime,
                                                getState().expectedPresentTime, outChanges);
        result != NO_ERROR) {
        ALOGE("chooseCompositionStrategy failed for %s: %d (%s)", getName().c_str(), result,
              strerror(-result));
        return false;
    }

    if (isPowerHintSessionEnabled()) {
        mPowerAdvisor->setHwcValidateTiming(mId, hwcValidateStartTime, TimePoint::now());
        if (auto halDisplayId = HalDisplayId::tryCast(mId)) {
            mPowerAdvisor->setSkippedValidate(mId, hwc.getValidateSkipped(*halDisplayId));
        }
    }

    return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

关注点 anyLayersRequireClientComposition 判断是否有 layer 需要 client 合成，也就是 GPU 合成：

// frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp
bool Output::anyLayersRequireClientComposition() const {
    // a C++11 range-based for loop
    // todo 学习一下这个语法
    // 用于获取 std::vector<std::unique_ptr<OutputLayer>> mCurrentOutputLayersOrderedByZ; 成员
    const auto layers = getOutputLayersOrderedByZ();
    return std::any_of(layers.begin(), layers.end(),
                       [](const auto& layer) { return layer->requiresClientComposition(); });
}

1
2
3
4
5
6
7
8
9

c++11 的语法，就是遍历，直到 lamda 表达式返回 true，如果所有成员都返回 false，那么最后就返回 false。

接着看 layer->requiresClientComposition()

// native/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp
bool OutputLayer::requiresClientComposition() const {
    const auto& state = getState();
    // hwcCompositionType 默认值是 Composition::INVALID，返回 false，所以默认不需要 client 合成
    // 后续会根据 hwc hal 的返回值，修改这个标志位
    return !state.hwc || state.hwc->hwcCompositionType == Composition::CLIENT;
}

1
2
3
4
5
6
7

也就是说需要 Output 中的每一个 OutputLayer 都是 client 合成，那么 Output 才是 client 合成，否则就是 device 合成。

接着看关注点 getDeviceCompositionChanges 发起远程调用，从 HWC HAL 中获取到指导渲染方式的数据，这些数据保存在参数 android::HWComposer::DeviceRequestedChanges outChanges 中，作为返回值。

chooseCompositionStrategy 选择的策略保存在 DeviceRequestedChanges 对象中：

    struct DeviceRequestedChanges {
        using ChangedTypes =
                std::unordered_map<HWC2::Layer*,
                                   aidl::android::hardware::graphics::composer3::Composition>;
        using ClientTargetProperty =
                aidl::android::hardware::graphics::composer3::ClientTargetPropertyWithBrightness;
        using DisplayRequests = hal::DisplayRequest;
        using LayerRequests = std::unordered_map<HWC2::Layer*, hal::LayerRequest>;

        ChangedTypes changedTypes;
        DisplayRequests displayRequests;
        LayerRequests layerRequests;
        ClientTargetProperty clientTargetProperty;
    };

1
2
3
4
5
6
7
8
9
10
11
12
13
14

getDeviceCompositionChanges 执行完成后，返回到上一级，会接着调用 applyCompositionStrategy：

// /frameworks/native/services/surfaceflinger/CompositionEngine/src/Display.cpp

void Display::applyCompositionStrategy(const std::optional<DeviceRequestedChanges>& changes) {
    if (changes) {
        applyChangedTypesToLayers(changes->changedTypes);
        applyDisplayRequests(changes->displayRequests);
        applyLayerRequestsToLayers(changes->layerRequests);
        applyClientTargetRequests(changes->clientTargetProperty);
    }

    // Determine what type of composition we are doing from the final state
    auto& state = editState();
    // 再次调用 anyLayersRequireClientComposition
    // Output 的渲染方式记录在 state 中
    state.usesClientComposition = anyLayersRequireClientComposition();
    state.usesDeviceComposition = !allLayersRequireClientComposition();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

把这些变化配置给 Layer，有很多数据，我们主要关注渲染方式相关数据：

// /frameworks/native/services/surfaceflinger/CompositionEngine/src/Display.cpp

void Display::applyChangedTypesToLayers(const ChangedTypes& changedTypes) {
    if (changedTypes.empty()) {
        return;
    }

    // 遍历成员 std::vector<std::unique_ptr<OutputLayer>> mCurrentOutputLayersOrderedByZ;
    for (auto* layer : getOutputLayersOrderedByZ()) {
        auto hwcLayer = layer->getHwcLayer();
        if (!hwcLayer) {
            continue;
        }

        if (auto it = changedTypes.find(hwcLayer); it != changedTypes.end()) {
            // 设置 OutputLayer 的渲染方式
            layer->applyDeviceCompositionTypeChange(
                    static_cast<aidl::android::hardware::graphics::composer3::Composition>(
                            it->second));
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

调用 applyDeviceCompositionTypeChange，设置 OutputLayer 的渲染方式：

// /frameworks/native/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp
void OutputLayer::applyDeviceCompositionTypeChange(Composition compositionType) {
    auto& state = editState();
    LOG_FATAL_IF(!state.hwc);
    auto& hwcState = *state.hwc;

    // Only detected disallowed changes if this was not a skip layer, because the
    // validated composition type may be arbitrary (usually DEVICE, to reflect that there were
    // fewer GPU layers)
    if (!hwcState.layerSkipped) {
        detectDisallowedCompositionTypeChange(hwcState.hwcCompositionType, compositionType);
    }

    // 直接设置 OutputLayer 的渲染方式
    hwcState.hwcCompositionType = compositionType;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

渲染方式保存在 hwcState 的 hwcCompositionType 成员中。

OutputLayer 的渲染方式有以下几个选项：

enum class Composition : int32_t {
  INVALID = 0,
  CLIENT = 1, // client，也就是 GPU 渲染
  DEVICE = 2,   // device，也就是硬件渲染
  SOLID_COLOR = 3,
  CURSOR = 4,
  SIDEBAND = 5,
  DISPLAY_DECORATION = 6,
  REFRESH_RATE_INDICATOR = 7,
};

1
2
3
4
5
6
7
8
9
10

小结一下：

getDeviceCompositionChanges 向 HWC HAL 获取协商合成方式
applyChangedTypesToLayers 将合成方式设置给 OutputLayer

接下来我们分析 hwc(HWComposer) 的 getDeviceCompositionChanges 函数如何向 HWC 获取合成策略：

status_t HWComposer::getDeviceCompositionChanges(
        HalDisplayId displayId, bool frameUsesClientComposition,
        std::optional<std::chrono::steady_clock::time_point> earliestPresentTime,
        nsecs_t expectedPresentTime,
        std::optional<android::HWComposer::DeviceRequestedChanges>* outChanges) {
    ATRACE_CALL();

    RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);

    auto& displayData = mDisplayData[displayId];
    auto& hwcDisplay = displayData.hwcDisplay;
    if (!hwcDisplay->isConnected()) {
        return NO_ERROR;
    }

    uint32_t numTypes = 0;
    uint32_t numRequests = 0;

    hal::Error error = hal::Error::NONE;

    // First try to skip validate altogether. We can do that when
    // 1. The previous frame has not been presented yet or already passed the
    // earliest time to present. Otherwise, we may present a frame too early.
    // 2. There is no client composition. Otherwise, we first need to render the
    // client target buffer.
    const bool canSkipValidate = [&] {
        // We must call validate if we have client composition
        if (frameUsesClientComposition) {
            return false;
        }

        // If composer supports getting the expected present time, we can skip
        // as composer will make sure to prevent early presentation
        if (!earliestPresentTime) {
            return true;
        }

        // composer doesn't support getting the expected present time. We can only
        // skip validate if we know that we are not going to present early.
        return std::chrono::steady_clock::now() >= *earliestPresentTime;
    }();

    displayData.validateWasSkipped = false;
    if (canSkipValidate) {
        sp<Fence> outPresentFence;
        uint32_t state = UINT32_MAX;
        // 关注点
        error = hwcDisplay->presentOrValidate(expectedPresentTime, &numTypes, &numRequests,
                                              &outPresentFence, &state);
        if (!hasChangesError(error)) {
            RETURN_IF_HWC_ERROR_FOR("presentOrValidate", error, displayId, UNKNOWN_ERROR);
        }
        if (state == 1) { //Present Succeeded.  纯 device 合成的情况
            std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
            error = hwcDisplay->getReleaseFences(&releaseFences);
            displayData.releaseFences = std::move(releaseFences);
            displayData.lastPresentFence = outPresentFence;
            displayData.validateWasSkipped = true;
            displayData.presentError = error;
            return NO_ERROR;
        }
        // Present failed but Validate ran.
    } else {
        error = hwcDisplay->validate(expectedPresentTime, &numTypes, &numRequests);
    }
    ALOGV("SkipValidate failed, Falling back to SLOW validate/present");
    if (!hasChangesError(error)) {
        RETURN_IF_HWC_ERROR_FOR("validate", error, displayId, BAD_INDEX);
    }

    // 获取 OutputLayer 合成相关信息
    android::HWComposer::DeviceRequestedChanges::ChangedTypes changedTypes;
    changedTypes.reserve(numTypes);

    // 关注点
    error = hwcDisplay->getChangedCompositionTypes(&changedTypes);
    RETURN_IF_HWC_ERROR_FOR("getChangedCompositionTypes", error, displayId, BAD_INDEX);

    auto displayRequests = static_cast<hal::DisplayRequest>(0);
    android::HWComposer::DeviceRequestedChanges::LayerRequests layerRequests;
    layerRequests.reserve(numRequests);
    // 关注点
    error = hwcDisplay->getRequests(&displayRequests, &layerRequests);
    RETURN_IF_HWC_ERROR_FOR("getRequests", error, displayId, BAD_INDEX);

    DeviceRequestedChanges::ClientTargetProperty clientTargetProperty;
    // 关注点
    error = hwcDisplay->getClientTargetProperty(&clientTargetProperty);

    // 存到返回值里面
    outChanges->emplace(DeviceRequestedChanges{std::move(changedTypes), std::move(displayRequests),
                                               std::move(layerRequests),
                                               std::move(clientTargetProperty)});
    error = hwcDisplay->acceptChanges();
    RETURN_IF_HWC_ERROR_FOR("acceptChanges", error, displayId, BAD_INDEX);

    return NO_ERROR;
}

不同的情况下分别调用 presentOrValidate 和 validate，两者的逻辑大致一致。

我们分析 presentOrValidate 所在的分支，presentOrValidate 一方面会将部分 Layer device 合成，同时返回一些数据告诉客户端哪些 layer 需要 client 合成：

// /android-14.0.0_r15/frameworks/native/services/surfaceflinger/DisplayHardware/HWC2.cpp
Error Display::presentOrValidate(nsecs_t expectedPresentTime, uint32_t* outNumTypes,
                                 uint32_t* outNumRequests, sp<android::Fence>* outPresentFence,
                                 uint32_t* state) {
    uint32_t numTypes = 0;
    uint32_t numRequests = 0;
    int32_t presentFenceFd = -1;
    // device 合成吗？
    auto intError = mComposer.presentOrValidateDisplay(mId, expectedPresentTime, &numTypes,
                                                       &numRequests, &presentFenceFd, state);
    auto error = static_cast<Error>(intError);
    if (error != Error::NONE && !hasChangesError(error)) {
        return error;
    }

    if (*state == 1) { //能够纯 device 合成的情况
        *outPresentFence = sp<Fence>::make(presentFenceFd);
    }

    if (*state == 0) { // 需要 client 合成 + device 合成的情况
        *outNumTypes = numTypes;
        *outNumRequests = numRequests;
    }
    return error;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

接着调用 mComposer.presentOrValidateDisplay：

// /frameworks/native/services/surfaceflinger/DisplayHardware/AidlComposerHal.cpp
Error AidlComposer::presentOrValidateDisplay(Display display, nsecs_t expectedPresentTime,
                                             uint32_t* outNumTypes, uint32_t* outNumRequests,
                                             int* outPresentFence, uint32_t* state) {
    const auto displayId = translate<int64_t>(display);
    ATRACE_FORMAT("HwcPresentOrValidateDisplay %" PRId64, displayId);

    Error error = Error::NONE;
    mMutex.lock_shared();
    auto writer = getWriter(display);
    auto reader = getReader(display);
    if (writer && reader) {
        // 关注点1
        writer->get().presentOrvalidateDisplay(displayId,
                                                   ClockMonotonicTimestamp{expectedPresentTime});

        error = execute(display);
    } else {
        error = Error::BAD_DISPLAY;
    }

    if (error != Error::NONE) {
        mMutex.unlock_shared();
        return error;
    }

    // 关注点 2 解析返回的数据
    const auto result = reader->get().takePresentOrValidateStage(displayId);
    if (!result.has_value()) {
        *state = translate<uint32_t>(-1);
        mMutex.unlock_shared();
        return Error::NO_RESOURCES;
    }

    *state = translate<uint32_t>(*result);

    // 能够纯 device 合成的情况，这种情况，合成就完成了
    if (*result == PresentOrValidate::Result::Presented) {
        auto fence = reader->get().takePresentFence(displayId);
        // take ownership
        *outPresentFence = fence.get();
        *fence.getR() = -1;
    }

    // 需要 client 合成 + device 合成的情况
    if (*result == PresentOrValidate::Result::Validated) {
        reader->get().hasChanges(displayId, outNumTypes, outNumRequests);
    }

    mMutex.unlock_shared();
    return Error::NONE;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

关注点1：presentOrvalidateDisplay + excute 发起远程调用，合成图层
关注点2：takePresentOrValidateStage 解析远程调用返回的数据

    void presentOrvalidateDisplay(int64_t display,
                                  std::optional<ClockMonotonicTimestamp> expectedPresentTime) {
        auto& command = getDisplayCommand(display);
        command.expectedPresentTime = expectedPresentTime;
        command.presentOrValidateDisplay = true;
    }

1
2
3
4
5
6

实际就是给 command 配置几个数据。

# 7.2.5 finishFrame

关注点 4，这里主要是 gpu 合成的情况

void Output::finishFrame(GpuCompositionResult&& result) {
    const auto& outputState = getState();
    if (!outputState.isEnabled) { 
        return;
    }

    std::optional<base::unique_fd> optReadyFence;

    std::shared_ptr<renderengine::ExternalTexture> buffer;
    base::unique_fd bufferFence;
  
    // 如果之前走的 prepareFrameAsync，这个状态位已经被标志城 SUCCESS。
    if (outputState.strategyPrediction == CompositionStrategyPredictionState::SUCCESS) {
        optReadyFence = std::move(result.fence);
    } else {
        // 否则就会走这里进行合成操作
        if (result.bufferAvailable()) {
            buffer = std::move(result.buffer);
            bufferFence = std::move(result.fence);
        } else { 
            // 如果有 layer 的内容是受保护的，通过 RenderSurface::setProtected 设置 window 特定 flag表 示需要保护
            updateProtectedContentState();
            // 关注点
            // 获取一个渲染 buffer，这个 buffer 也是一个 GraphicBuffer，通过调用 RenderSurafce::dequeueBuffer 实现的
            // 而 RenderSurafce 本质就是通过一个 ANativeWindow 实现使用 gpu 去做绘制操作。
            if (!dequeueRenderBuffer(&bufferFence, &buffer)) {
                return;
            }
        }
        // GPU 合成操作
        optReadyFence = composeSurfaces(Region::INVALID_REGION, buffer, bufferFence);
    }
    if (!optReadyFence) {
        return;
    }

    if (isPowerHintSessionEnabled()) {
        setHintSessionGpuFence(
                std::make_unique<FenceTime>(sp<Fence>::make(dup(optReadyFence->get()))));
    }

    // 将合成后的 Buffer 提交给 HWC
    // 关键是怎么让消费者调用到 acquireBuffer
    mRenderSurface->queueBuffer(std::move(*optReadyFence));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

dequeueRenderBuffer 获取 buffer：

bool Output::dequeueRenderBuffer(base::unique_fd* bufferFence,
                                 std::shared_ptr<renderengine::ExternalTexture>* tex) {
    const auto& outputState = getState();

    // If we aren't doing client composition on this output, but do have a
    // flipClientTarget request for this frame on this output, we still need to
    // dequeue a buffer.
    if (outputState.usesClientComposition || outputState.flipClientTarget) {
        *tex = mRenderSurface->dequeueBuffer(bufferFence);
        if (*tex == nullptr) {
            ALOGW("Dequeuing buffer for display [%s] failed, bailing out of "
                  "client composition for this frame",
                  mName.c_str());
            return false;
        }
    }
    return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

调用 mRenderSurface->dequeueBuffer：

std::shared_ptr<renderengine::ExternalTexture> RenderSurface::dequeueBuffer(
        base::unique_fd* bufferFence) {
    ATRACE_CALL();
    int fd = -1;
    ANativeWindowBuffer* buffer = nullptr;

    status_t result = mNativeWindow->dequeueBuffer(mNativeWindow.get(), &buffer, &fd);

    if (result != NO_ERROR) {
        ALOGE("ANativeWindow::dequeueBuffer failed for display [%s] with error: %d",
              mDisplay.getName().c_str(), result);
        // Return fast here as we can't do much more - any rendering we do
        // now will just be wrong.
        return mTexture;
    }

    ALOGW_IF(mTexture != nullptr, "Clobbering a non-null pointer to a buffer [%p].",
             mTexture->getBuffer()->getNativeBuffer()->handle);

    sp<GraphicBuffer> newBuffer = GraphicBuffer::from(buffer);

    std::shared_ptr<renderengine::ExternalTexture> texture;

    for (auto it = mTextureCache.begin(); it != mTextureCache.end(); it++) {
        const auto& cachedTexture = *it;
        if (cachedTexture->getBuffer()->getId() == newBuffer->getId()) {
            texture = cachedTexture;
            mTextureCache.erase(it);
            break;
        }
    }

    if (texture) {
        mTexture = texture;
    } else {
        // 构建一个 ExternalTexture 返回
        mTexture = std::make_shared<
                renderengine::impl::ExternalTexture>(GraphicBuffer::from(buffer),
                                                     mCompositionEngine.getRenderEngine(),
                                                     renderengine::impl::ExternalTexture::Usage::
                                                             WRITEABLE);
    }

    // 缓存
    mTextureCache.push_back(mTexture);
    if (mTextureCache.size() > mMaxTextureCacheSize) {
        mTextureCache.erase(mTextureCache.begin());
    }

    *bufferFence = base::unique_fd(fd);

    return mTexture;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

mNativeWindow 的实际类型是 Surface，mNativeWindow->dequeueBuffer 的实现如下：

int Surface::dequeueBuffer(android_native_buffer_t** buffer, int* fenceFd) {
    ATRACE_FORMAT("dequeueBuffer - %s", getDebugName());
    ALOGV("Surface::dequeueBuffer");

    IGraphicBufferProducer::DequeueBufferInput dqInput;
    {
        Mutex::Autolock lock(mMutex);
        if (mReportRemovedBuffers) {
            mRemovedBuffers.clear();
        }

        getDequeueBufferInputLocked(&dqInput);

        if (mSharedBufferMode && mAutoRefresh && mSharedBufferSlot !=
                BufferItem::INVALID_BUFFER_SLOT) {
            sp<GraphicBuffer>& gbuf(mSlots[mSharedBufferSlot].buffer);
            if (gbuf != nullptr) {
                *buffer = gbuf.get();
                *fenceFd = -1;
                return OK;
            }
        }
    } // Drop the lock so that we can still touch the Surface while blocking in IGBP::dequeueBuffer

    int buf = -1;
    sp<Fence> fence;
    nsecs_t startTime = systemTime();

    FrameEventHistoryDelta frameTimestamps;

    //从 producer 获取 buffer 和 fence
    status_t result = mGraphicBufferProducer->dequeueBuffer(&buf, &fence, dqInput.width,
                                                            dqInput.height, dqInput.format,
                                                            dqInput.usage, &mBufferAge,
                                                            dqInput.getTimestamps ?
                                                                    &frameTimestamps : nullptr);
    mLastDequeueDuration = systemTime() - startTime;

    if (result < 0) {
        ALOGV("dequeueBuffer: IGraphicBufferProducer::dequeueBuffer"
                "(%d, %d, %d, %#" PRIx64 ") failed: %d",
                dqInput.width, dqInput.height, dqInput.format, dqInput.usage, result);
        return result;
    }

    if (buf < 0 || buf >= NUM_BUFFER_SLOTS) {
        ALOGE("dequeueBuffer: IGraphicBufferProducer returned invalid slot number %d", buf);
        android_errorWriteLog(0x534e4554, "36991414"); // SafetyNet logging
        return FAILED_TRANSACTION;
    }

    Mutex::Autolock lock(mMutex);

    // Write this while holding the mutex
    mLastDequeueStartTime = startTime;

    sp<GraphicBuffer>& gbuf(mSlots[buf].buffer);

    // this should never happen
    ALOGE_IF(fence == nullptr, "Surface::dequeueBuffer: received null Fence! buf=%d", buf);

    if (CC_UNLIKELY(atrace_is_tag_enabled(ATRACE_TAG_GRAPHICS))) {
        static gui::FenceMonitor hwcReleaseThread("HWC release");
        hwcReleaseThread.queueFence(fence);
    }

    if (result & IGraphicBufferProducer::RELEASE_ALL_BUFFERS) {
        freeAllBuffers();
    }

    if (dqInput.getTimestamps) {
         mFrameEventHistory->applyDelta(frameTimestamps);
    }

    if ((result & IGraphicBufferProducer::BUFFER_NEEDS_REALLOCATION) || gbuf == nullptr) {
        if (mReportRemovedBuffers && (gbuf != nullptr)) {
            mRemovedBuffers.push_back(gbuf);
        }
        result = mGraphicBufferProducer->requestBuffer(buf, &gbuf);
        if (result != NO_ERROR) {
            ALOGE("dequeueBuffer: IGraphicBufferProducer::requestBuffer failed: %d", result);
            mGraphicBufferProducer->cancelBuffer(buf, fence);
            return result;
        }
    }

    if (fence->isValid()) {
        *fenceFd = fence->dup();
        if (*fenceFd == -1) {
            ALOGE("dequeueBuffer: error duping fence: %d", errno);
            // dup() should never fail; something is badly wrong. Soldier on
            // and hope for the best; the worst that should happen is some
            // visible corruption that lasts until the next frame.
        }
    } else {
        *fenceFd = -1;
    }

    *buffer = gbuf.get();

    if (mSharedBufferMode && mAutoRefresh) {
        mSharedBufferSlot = buf;
        mSharedBufferHasBeenQueued = false;
    } else if (mSharedBufferSlot == buf) {
        mSharedBufferSlot = BufferItem::INVALID_BUFFER_SLOT;
        mSharedBufferHasBeenQueued = false;
    }

    mDequeuedSlots.insert(buf);

    return OK;
}

拿到 buffer 后就可以调用 composeSurfaces 开始 gpu 合成了

std::optional<base::unique_fd> Output::composeSurfaces(
        const Region& debugRegion, std::shared_ptr<renderengine::ExternalTexture> tex,
        base::unique_fd& fd) {

    // 判断是否是需要 gpu 合成，不是就直接返回
    const auto& outputState = getState();
    const TracedOrdinal<bool> hasClientComposition = {
        base::StringPrintf("hasClientComposition %s", mNamePlusId.c_str()),
        outputState.usesClientComposition};
      
    if (!hasClientComposition) {
        setExpensiveRenderingExpected(false);
        return base::unique_fd();
    }

    if (tex == nullptr) {
        ALOGW("Buffer not valid for display [%s], bailing out of "
              "client composition for this frame",
              mName.c_str());
        return {};
    }

    ALOGV("hasClientComposition");


    renderengine::DisplaySettings clientCompositionDisplay =
            generateClientCompositionDisplaySettings();

    auto& renderEngine = getCompositionEngine().getRenderEngine();
    const bool supportsProtectedContent = renderEngine.supportsProtectedContent();
    std::vector<LayerFE*> clientCompositionLayersFE;
    // 调用 generateClientCompositionRequests，所有 OutputLayer 里，需要 gpu 合成的 layer 都会生成一个 LayerSettings
    std::vector<LayerFE::LayerSettings> clientCompositionLayers =
            generateClientCompositionRequests(supportsProtectedContent,
                                            clientCompositionDisplay.outputDataspace,
                                            clientCompositionLayersFE);

    appendRegionFlashRequests(debugRegion, clientCompositionLayers);

    OutputCompositionState& outputCompositionState = editState();
    // 。。。 检查缓存，如果合成结果已经有缓存了，这里就不重新进行合成，直接返回了

    // 如果这里合成有色彩空间转换等复杂计算，会提高gpu频率
    const bool expensiveRenderingExpected =
            std::any_of(clientCompositionLayers.begin(), clientCompositionLayers.end(),
                        [outputDataspace =
                                clientCompositionDisplay.outputDataspace](const auto& layer) {
                            return layer.sourceDataspace != outputDataspace;
                        });
    if (expensiveRenderingExpected) {
        setExpensiveRenderingExpected(true);
    }

    // 将参数存储到clientRenderEngineLayers
    std::vector<renderengine::LayerSettings> clientRenderEngineLayers;
    clientRenderEngineLayers.reserve(clientCompositionLayers.size());
    std::transform(clientCompositionLayers.begin(), clientCompositionLayers.end(),
                std::back_inserter(clientRenderEngineLayers),
                [](LayerFE::LayerSettings& settings) -> renderengine::LayerSettings {
                    return settings;
                });

    const nsecs_t renderEngineStart = systemTime();
    const bool useFramebufferCache = outputState.layerFilter.toInternalDisplay;
    // 调用drawLayers，使用gpu进行合成渲染操作，返回一个gpu fence，用于确认gpu是否完成工作。
    // 这里的renderEngine是RenderEngine子类，根据属性会有不同的实现，默认是GLESRenderEngine
    // GLESRenderEngine.drawLayers通过gles api给gpu下发指令，渲染合成所有layer内的buffer。
    auto fenceResult = renderEngine
                            .drawLayers(clientCompositionDisplay, clientRenderEngineLayers, tex,
                                        useFramebufferCache, std::move(fd))
                            .get();

    if (mClientCompositionRequestCache && fenceStatus(fenceResult) != NO_ERROR) {
        mClientCompositionRequestCache->remove(tex->getBuffer()->getId());
    }

    const auto fence = std::move(fenceResult).value_or(Fence::NO_FENCE);

    // 。。。记录一些时间信息

    for (auto* clientComposedLayer : clientCompositionLayersFE) {
        clientComposedLayer->setWasClientComposed(fence);
    }

    return base::unique_fd(fence->dup());
}

合成逻辑，调用 generateClientCompositionRequests 整合参数，将需要用 gpu 合成的 layer 需要用到的参数封装成一个 LayerSettings，然后调用 RendorEngine 调 drawLayers

RendorEngine类型有不同子类，对应使用不同的方式去渲染合成，默认是GLESRendorEngine::drawLayers,使用GLES去控制gpu，下指令给GPU将所有的LayerSettings的Buffer进行渲染合成。最终合成结果会存在 tex，然后返回到上一层。

生成 DisplaySettings 的过程：

td::vector<LayerFE::LayerSettings> Output::generateClientCompositionRequests(
      bool supportsProtectedContent, ui::Dataspace outputDataspace, std::vector<LayerFE*>& outLayerFEs) {
    std::vector<LayerFE::LayerSettings> clientCompositionLayers;
    ALOGV("Rendering client layers");

    const auto& outputState = getState();
    const Region viewportRegion(outputState.layerStackSpace.getContent());
    bool firstLayer = true;

    bool disableBlurs = false;
    uint64_t previousOverrideBufferId = 0;

    // 遍历 output 中的 OutputLayer
    for (auto* layer : getOutputLayersOrderedByZ()) {
        const auto& layerState = layer->getState();
        const auto* layerFEState = layer->getLayerFE().getCompositionState();
        auto& layerFE = layer->getLayerFE();
        layerFE.setWasClientComposed(nullptr);

        const Region clip(viewportRegion.intersect(layerState.visibleRegion));
        ALOGV("Layer: %s", layerFE.getDebugName());
        if (clip.isEmpty()) {
            ALOGV("  Skipping for empty clip");
            firstLayer = false;
            continue;
        }

        disableBlurs |= layerFEState->sidebandStream != nullptr;

        const bool clientComposition = layer->requiresClientComposition();

        // We clear the client target for non-client composed layers if
        // requested by the HWC. We skip this if the layer is not an opaque
        // rectangle, as by definition the layer must blend with whatever is
        // underneath. We also skip the first layer as the buffer target is
        // guaranteed to start out cleared.
        const bool clearClientComposition =
                layerState.clearClientTarget && layerFEState->isOpaque && !firstLayer;

        ALOGV("  Composition type: client %d clear %d", clientComposition, clearClientComposition);

        // If the layer casts a shadow but the content casting the shadow is occluded, skip
        // composing the non-shadow content and only draw the shadows.
        const bool realContentIsVisible = clientComposition &&
                !layerState.visibleRegion.subtract(layerState.shadowRegion).isEmpty();

        if (clientComposition || clearClientComposition) {
            if (auto overrideSettings = layer->getOverrideCompositionSettings()) {
                if (overrideSettings->bufferId != previousOverrideBufferId) {
                    previousOverrideBufferId = overrideSettings->bufferId;
                    clientCompositionLayers.push_back(std::move(*overrideSettings));
                    ALOGV("Replacing [%s] with override in RE", layer->getLayerFE().getDebugName());
                } else {
                    ALOGV("Skipping redundant override buffer for [%s] in RE",
                          layer->getLayerFE().getDebugName());
                }
            } else {
                LayerFE::ClientCompositionTargetSettings::BlurSetting blurSetting = disableBlurs
                        ? LayerFE::ClientCompositionTargetSettings::BlurSetting::Disabled
                        : (layer->getState().overrideInfo.disableBackgroundBlur
                                   ? LayerFE::ClientCompositionTargetSettings::BlurSetting::
                                             BlurRegionsOnly
                                   : LayerFE::ClientCompositionTargetSettings::BlurSetting::
                                             Enabled);
                compositionengine::LayerFE::ClientCompositionTargetSettings
                        targetSettings{.clip = clip,
                                       .needsFiltering = layer->needsFiltering() ||
                                               outputState.needsFiltering,
                                       .isSecure = outputState.isSecure,
                                       .supportsProtectedContent = supportsProtectedContent,
                                       .viewport = outputState.layerStackSpace.getContent(),
                                       .dataspace = outputDataspace,
                                       .realContentIsVisible = realContentIsVisible,
                                       .clearContent = !clientComposition,
                                       .blurSetting = blurSetting,
                                       .whitePointNits = layerState.whitePointNits,
                                       .treat170mAsSrgb = outputState.treat170mAsSrgb};
                if (auto clientCompositionSettings =
                            layerFE.prepareClientComposition(targetSettings)) {
                    clientCompositionLayers.push_back(std::move(*clientCompositionSettings));
                    if (realContentIsVisible) {
                        layer->editState().clientCompositionTimestamp = systemTime();
                    }
                }
            }

            if (clientComposition) {
                outLayerFEs.push_back(&layerFE);
            }
        }

        firstLayer = false;
    }

    return clientCompositionLayers;
}

struct LayerSettings {
    // Geometry information
    Geometry geometry = Geometry();

    // Source pixels for this layer.
    PixelSource source = PixelSource();

    // Alpha option to blend with the source pixels
    half alpha = half(0.0);

    // Color space describing how the source pixels should be interpreted.
    ui::Dataspace sourceDataspace = ui::Dataspace::UNKNOWN;

    // Additional layer-specific color transform to be applied before the global
    // transform.
    mat4 colorTransform = mat4();

    // True if blending will be forced to be disabled.
    bool disableBlending = false;

    // If true, then this layer casts a shadow and/or blurs behind it, but it does
    // not otherwise draw any of the layer's other contents.
    bool skipContentDraw = false;

    ShadowSettings shadow;

    int backgroundBlurRadius = 0;

    std::vector<BlurRegion> blurRegions;

    // Transform matrix used to convert the blurRegions geometry into the same
    // coordinate space as LayerSettings.geometry
    mat4 blurRegionTransform = mat4();

    StretchEffect stretchEffect;

    // Name associated with the layer for debugging purposes.
    std::string name;

    // Luminance of the white point for this layer. Used for linear dimming.
    // Individual layers will be dimmed by (whitePointNits / maxWhitePoint).
    // If white point nits are unknown, then this layer is assumed to have the
    // same luminance as the brightest layer in the scene.
    float whitePointNits = -1.f;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

gpu 合成好了以后，调用 mRenderSurface->queueBuffer ：


void RenderSurface::queueBuffer(base::unique_fd readyFence) {
    auto& state = mDisplay.getState();

    if (state.usesClientComposition || state.flipClientTarget) {
        // hasFlipClientTargetRequest could return true even if we haven't
        // dequeued a buffer before. Try dequeueing one if we don't have a
        // buffer ready.
        if (mTexture == nullptr) {
            ALOGI("Attempting to queue a client composited buffer without one "
                  "previously dequeued for display [%s]. Attempting to dequeue "
                  "a scratch buffer now",
                  mDisplay.getName().c_str());
            // We shouldn't deadlock here, since mTexture == nullptr only
            // after a successful call to queueBuffer, or if dequeueBuffer has
            // never been called.
            base::unique_fd unused;
            dequeueBuffer(&unused);
        }

        if (mTexture == nullptr) {
            ALOGE("No buffer is ready for display [%s]", mDisplay.getName().c_str());
        } else {
            // 插入 buffer
            status_t result = mNativeWindow->queueBuffer(mNativeWindow.get(),
                                                         mTexture->getBuffer()->getNativeBuffer(),
                                                         dup(readyFence));
            if (result != NO_ERROR) {
                ALOGE("Error when queueing buffer for display [%s]: %d", mDisplay.getName().c_str(),
                      result);
                // We risk blocking on dequeueBuffer if the primary display failed
                // to queue up its buffer, so crash here.
                if (!mDisplay.isVirtual()) {
                    LOG_ALWAYS_FATAL("ANativeWindow::queueBuffer failed with error: %d", result);
                } else {
                    mNativeWindow->cancelBuffer(mNativeWindow.get(),
                                                mTexture->getBuffer()->getNativeBuffer(),
                                                dup(readyFence));
                }
            }

            mTexture = nullptr;
        }
    }

    // 消费者获取 buffer 消费
    status_t result = mDisplaySurface->advanceFrame();
    if (result != NO_ERROR) {
        ALOGE("[%s] failed pushing new frame to HWC: %d", mDisplay.getName().c_str(), result);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

和 App 端通过回调实现不同，这里直接调用：

status_t FramebufferSurface::advanceFrame() {
    Mutex::Autolock lock(mMutex);

    BufferItem item;

    // 获取 buffer
    status_t err = acquireBufferLocked(&item, 0);
    if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
        mDataspace = Dataspace::UNKNOWN;
        return NO_ERROR;
    } else if (err != NO_ERROR) {
        ALOGE("error acquiring buffer: %s (%d)", strerror(-err), err);
        mDataspace = Dataspace::UNKNOWN;
        return err;
    }

    // If the BufferQueue has freed and reallocated a buffer in mCurrentSlot
    // then we may have acquired the slot we already own.  If we had released
    // our current buffer before we call acquireBuffer then that release call
    // would have returned STALE_BUFFER_SLOT, and we would have called
    // freeBufferLocked on that slot.  Because the buffer slot has already
    // been overwritten with the new buffer all we have to do is skip the
    // releaseBuffer call and we should be in the same state we'd be in if we
    // had released the old buffer first.
    if (mCurrentBufferSlot != BufferQueue::INVALID_BUFFER_SLOT &&
        item.mSlot != mCurrentBufferSlot) {
        mHasPendingRelease = true;
        mPreviousBufferSlot = mCurrentBufferSlot;
        mPreviousBuffer = mCurrentBuffer;
    }
    mCurrentBufferSlot = item.mSlot;
    mCurrentBuffer = mSlots[mCurrentBufferSlot].mGraphicBuffer;
    mCurrentFence = item.mFence;
    mDataspace = static_cast<Dataspace>(item.mDataSpace);

    // assume HWC has previously seen the buffer in this slot
    sp<GraphicBuffer> hwcBuffer = sp<GraphicBuffer>(nullptr);
    if (mCurrentBuffer->getId() != mHwcBufferIds[mCurrentBufferSlot]) {
        mHwcBufferIds[mCurrentBufferSlot] = mCurrentBuffer->getId();
        hwcBuffer = mCurrentBuffer; // HWC hasn't previously seen this buffer in this slot
    }

    // 发起后续 device 合成
    status_t result = mHwc.setClientTarget(mDisplayId, mCurrentBufferSlot, mCurrentFence, hwcBuffer,
                                           mDataspace);
    if (result != NO_ERROR) {
        ALOGE("error posting framebuffer: %s (%d)", strerror(-result), result);
        return result;
    }

    return NO_ERROR;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

status_t HWComposer::setClientTarget(HalDisplayId displayId, uint32_t slot,
                                     const sp<Fence>& acquireFence, const sp<GraphicBuffer>& target,
                                     ui::Dataspace dataspace) {
    RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);

    ALOGV("%s for display %s", __FUNCTION__, to_string(displayId).c_str());
    auto& hwcDisplay = mDisplayData[displayId].hwcDisplay;
    auto error = hwcDisplay->setClientTarget(slot, target, acquireFence, dataspace);
    RETURN_IF_HWC_ERROR(error, displayId, BAD_VALUE);
    return NO_ERROR;
}

1
2
3
4
5
6
7
8
9
10
11

Error Display::setClientTarget(uint32_t slot, const sp<GraphicBuffer>& target,
        const sp<Fence>& acquireFence, Dataspace dataspace)
{
    // TODO: Properly encode client target surface damage
    int32_t fenceFd = acquireFence->dup();
    auto intError = mComposer.setClientTarget(mId, slot, target,
            fenceFd, dataspace, std::vector<Hwc2::IComposerClient::Rect>());
    return static_cast<Error>(intError);
}

1
2
3
4
5
6
7
8
9

Error AidlComposer::setClientTarget(Display display, uint32_t slot, const sp<GraphicBuffer>& target,
                                    int acquireFence, Dataspace dataspace,
                                    const std::vector<IComposerClient::Rect>& damage) {
    const native_handle_t* handle = nullptr;
    if (target.get()) {
        handle = target->getNativeBuffer()->handle;
    }

    Error error = Error::NONE;
    mMutex.lock_shared();
    if (auto writer = getWriter(display)) {
        writer->get()
                .setClientTarget(translate<int64_t>(display), slot, handle, acquireFence,
                                 translate<aidl::android::hardware::graphics::common::Dataspace>(
                                         dataspace),
                                 translate<AidlRect>(damage));
    } else {
        error = Error::BAD_DISPLAY;
    }
    mMutex.unlock_shared();
    return error;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

    void setClientTarget(int64_t display, uint32_t slot, const native_handle_t* target,
                         int acquireFence, Dataspace dataspace, const std::vector<Rect>& damage) {
        ClientTarget clientTargetCommand;
        clientTargetCommand.buffer = getBufferCommand(slot, target, acquireFence);
        clientTargetCommand.dataspace = dataspace;
        clientTargetCommand.damage.assign(damage.begin(), damage.end());
        getDisplayCommand(display).clientTarget.emplace(std::move(clientTargetCommand));
    }

1
2
3
4
5
6
7
8
9

没有合成，只是设置好数据

关注点5，这里会发起合成的远程调用：

void Output::postFramebuffer() {
    ATRACE_FORMAT("%s for %s", __func__, mNamePlusId.c_str());
    ALOGV(__FUNCTION__);

    if (!getState().isEnabled) {
        return;
    }

    auto& outputState = editState();
    outputState.dirtyRegion.clear();

    auto frame = presentAndGetFrameFences();

    mRenderSurface->onPresentDisplayCompleted();

    for (auto* layer : getOutputLayersOrderedByZ()) {
        // The layer buffer from the previous frame (if any) is released
        // by HWC only when the release fence from this frame (if any) is
        // signaled.  Always get the release fence from HWC first.
        sp<Fence> releaseFence = Fence::NO_FENCE;

        if (auto hwcLayer = layer->getHwcLayer()) {
            if (auto f = frame.layerFences.find(hwcLayer); f != frame.layerFences.end()) {
                releaseFence = f->second;
            }
        }

        // If the layer was client composited in the previous frame, we
        // need to merge with the previous client target acquire fence.
        // Since we do not track that, always merge with the current
        // client target acquire fence when it is available, even though
        // this is suboptimal.
        // TODO(b/121291683): Track previous frame client target acquire fence.
        if (outputState.usesClientComposition) {
            releaseFence =
                    Fence::merge("LayerRelease", releaseFence, frame.clientTargetAcquireFence);
        }
        layer->getLayerFE()
                .onLayerDisplayed(ftl::yield<FenceResult>(std::move(releaseFence)).share(),
                                  outputState.layerFilter.layerStack);
    }

    // We've got a list of layers needing fences, that are disjoint with
    // OutputLayersOrderedByZ.  The best we can do is to
    // supply them with the present fence.
    for (auto& weakLayer : mReleasedLayers) {
        if (const auto layer = weakLayer.promote()) {
            layer->onLayerDisplayed(ftl::yield<FenceResult>(frame.presentFence).share(),
                                    outputState.layerFilter.layerStack);
        }
    }

    // Clear out the released layers now that we're done with them.
    mReleasedLayers.clear();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

presentAndGetFrameFences 发起合成：

compositionengine::Output::FrameFences Display::presentAndGetFrameFences() {
    auto fences = impl::Output::presentAndGetFrameFences();

    const auto halDisplayIdOpt = HalDisplayId::tryCast(mId);
    if (mIsDisconnected || !halDisplayIdOpt) {
        return fences;
    }

    auto& hwc = getCompositionEngine().getHwComposer();

    const TimePoint startTime = TimePoint::now();

    if (isPowerHintSessionEnabled() && getState().earliestPresentTime) {
        mPowerAdvisor->setHwcPresentDelayedTime(mId, *getState().earliestPresentTime);
    }

    // 关注点
    hwc.presentAndGetReleaseFences(*halDisplayIdOpt, getState().earliestPresentTime);

    if (isPowerHintSessionEnabled()) {
        mPowerAdvisor->setHwcPresentTiming(mId, startTime, TimePoint::now());
    }

    fences.presentFence = hwc.getPresentFence(*halDisplayIdOpt);

    // TODO(b/121291683): Change HWComposer call to return entire map
    for (const auto* layer : getOutputLayersOrderedByZ()) {
        auto hwcLayer = layer->getHwcLayer();
        if (!hwcLayer) {
            continue;
        }

        fences.layerFences.emplace(hwcLayer, hwc.getLayerReleaseFence(*halDisplayIdOpt, hwcLayer));
    }

    hwc.clearReleaseFences(*halDisplayIdOpt);

    return fences;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

接着调用 presentAndGetReleaseFences：

status_t HWComposer::presentAndGetReleaseFences(
        HalDisplayId displayId,
        std::optional<std::chrono::steady_clock::time_point> earliestPresentTime) {
    ATRACE_CALL();

    RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);

    auto& displayData = mDisplayData[displayId];
    auto& hwcDisplay = displayData.hwcDisplay;

    if (displayData.validateWasSkipped) {
        // 执行 command
        // explicitly flush all pending commands
        auto error = static_cast<hal::Error>(mComposer->executeCommands(hwcDisplay->getId()));
        RETURN_IF_HWC_ERROR_FOR("executeCommands", error, displayId, UNKNOWN_ERROR);
        RETURN_IF_HWC_ERROR_FOR("present", displayData.presentError, displayId, UNKNOWN_ERROR);
        return NO_ERROR;
    }

    if (earliestPresentTime) {
        ATRACE_NAME("wait for earliest present time");
        std::this_thread::sleep_until(*earliestPresentTime);
    }

    // 关注点
    auto error = hwcDisplay->present(&displayData.lastPresentFence);
    RETURN_IF_HWC_ERROR_FOR("present", error, displayId, UNKNOWN_ERROR);

    std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
    error = hwcDisplay->getReleaseFences(&releaseFences);
    RETURN_IF_HWC_ERROR_FOR("getReleaseFences", error, displayId, UNKNOWN_ERROR);

    displayData.releaseFences = std::move(releaseFences);

    return NO_ERROR;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

不同情况下调用 executeCommands 或者 present：

Error AidlComposer::executeCommands(Display display) {
    mMutex.lock_shared();
    auto error = execute(display);
    mMutex.unlock_shared();
    return error;
}

1
2
3
4
5
6

Error Display::present(sp<Fence>* outPresentFence)
{
    int32_t presentFenceFd = -1;
    auto intError = mComposer.presentDisplay(mId, &presentFenceFd);
    auto error = static_cast<Error>(intError);
    if (error != Error::NONE) {
        return error;
    }

    *outPresentFence = sp<Fence>::make(presentFenceFd);
    return Error::NONE;
}

1
2
3
4
5
6
7
8
9
10
11
12

Error AidlComposer::presentDisplay(Display display, int* outPresentFence) {
    const auto displayId = translate<int64_t>(display);
    ATRACE_FORMAT("HwcPresentDisplay %" PRId64, displayId);

    Error error = Error::NONE;
    mMutex.lock_shared();
    auto writer = getWriter(display);
    auto reader = getReader(display);
    if (writer && reader) {
        writer->get().presentDisplay(displayId);
        error = execute(display);
    } else {
        error = Error::BAD_DISPLAY;
    }

    if (error != Error::NONE) {
        mMutex.unlock_shared();
        return error;
    }

    auto fence = reader->get().takePresentFence(displayId);
    mMutex.unlock_shared();
    // take ownership
    *outPresentFence = fence.get();
    *fence.getR() = -1;
    return Error::NONE;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

无论哪种情况都会执行 command，合成图层，整个过程结束。

10.Choreographer机制解读 12.Android14 WMS AMS 窗口层级结构解析

Android Framework

Choose mode